Need helper class for Bitfields in Struct & MappedArray classes about bsp_tool HOT 2 CLOSED

Proposal:

give members a Bitfield class from a dict
bitfield repr can show each member, bitfield members can be accessed by name as top level class members

MappedArray:

class FirstExample(base.MappedArray):
    _mapping = ["member", "bitfield"]
    _format = "hi"
    _bitfields = {"bitfield": [("a", 8), ("b", 16), ("c", 8)]}

struct FirstExample {
    uint16_t  member;
    uint32_t  a: 8, b: 16, c: 8;
}

Struct:

class SecondExample(base.Struct):
    __slots__ = ["member", "child"]
    _format = "2hi"
    _arrays = {"child": ["member", "bitfield"]}
    _bitfields = {"child.bitfield": [("a", 8), ("b", 16), ("c", 8)]}
    # if "." in _bitfields_key, add _bitfields to child
    # else _bitfields_key = Bitfield(...)

struct SecondExample {
    uint16_t  member;
    struct {
        uint16_t  member;
        uint32_t  a: 8, b: 16, c: 8;
    } child;
};

Use:

>>> fe = FirstExample.frombytes(b"\x11\x11\xCC\xBB\xBB\xAA")
>>> fe.bitfield
<Bitfield (a: 0xAA, b: 0xBBBB, c: 0xCC)>
>>> fe.a
0xAA

All of this will require some checks (or at least tests w/ warnings):

• Fields to cover the whole bitfield type (need to match struct type char to bitfield)
• Bitfield must know it's type to create a inverted mask
  • in @b.setter: bitfield = b << 8 | bitfield & (2 ** 32 - 1 ^ (2 ** 8 - 1) << 8)
    could probably build a mask dict in __init__ ...
    number of calculations per lookup should be minimal, so calculate constants in __init__

We'll also be overlapping with other planned MappedArray & Struct features:

• subclasses (e.g. DisplacementNeighbour(base.Struct) or _subclasses = {"origin": vec3})
• C struct conversion / repr (be sure to use stdint)
• unpacking _format & matching each member to a type (part of C conversion)

If the BitField class handles all the getting & setting, the LumpClass can just access the bitfield members

from bsp_tool.

commit 810cb7e introduces this feature

from bsp_tool.