deploy: 07d2476

Author: MatrixEditor

_sources/reference/basic/bit_string.rst.txt

@@ -4,117 +4,101 @@ BIT STRING
 ==========
 
 The ASN.1 ``BIT STRING`` type represents an arbitrary-length sequence of bits.
-It is used to model flags, bitmasks, and other bit-level data. These types store
-their bit data internally as a little-endian encoded byte array.
+It is used to model flags, bitmasks, and other bit-level data. In the generated
+Python bindings, **all** ``BIT STRING`` types implement type behavior described
+in :class:`_Asn1BitStrType`.
 
-Named BIT STRING types are special variants where each bit is assigned a
-meaningful name, represented as members of an ``enum.IntFlag`` class called
-``VALUES`` in the generated Python class.
+Named ``BIT STRING`` types additionally expose named boolean attributes for
+convenient flag access.
 
 Example ASN.1 definitions:
 
 .. code-block:: asn1
 
-    MyBitString ::= BIT STRING
+    ExampleBitString ::= BIT STRING
 
-    MyFlags ::= BIT STRING {
-        flag1(0),
-        flag2(1),
-        flag3(2)
+    ExampleNamedBitString ::= BIT STRING {
+        zero(0),
+        one(1),
+        two(2)
     }
 
 These generate Python classes similar to:
 
 .. code-block:: python
 
-    class MyBitString(_Asn1BasicType[bitarray.bitarray]):
+    class ExampleBitString(_Asn1BitStrType):
         pass
 
-    class MyFlags(_BasicAsn1FlagType):
-        class VALUES(enum.IntFlag):
-            V_flag1 = 0
-            V_flag2 = 1
-            V_flag3 = 2
+    class ExampleNamedBitString(_Asn1BitStrType):
+        V_zero: bool  # bit 0
+        V_one: bool   # bit 1
+        V_two: bool   # bit 2
 
 Conceptual Representation
 --------------------------
 
-.. py:class:: _Asn1BasicType[bitarray]
-    :no-index:
+.. py:class:: _Asn1BitStrType
 
-    Represents a basic ASN.1 BIT STRING.
+    Base class for all ASN.1 ``BIT STRING`` types.
 
-    .. py:method:: __init__(self, value: bytes | bitarray.bitarray | None = None) -> None
-        :no-index:
+    .. py:method:: __init__(self, size: int = ...) -> None
 
-        Initializes the BIT STRING instance with optional initial bits.
+        Initializes a ``BIT STRING`` with the given number of **bytes**.
 
-        The value can be:
+    .. py:property:: value
+        :type: bitarray.bitarray | bytes
 
-        - a bytes object representing the raw bits,
-        - a ``bitarray.bitarray`` instance,
-        - or ``None`` to initialize an empty BIT STRING.
+        Gets or sets the raw value of the ``BIT STRING``.
 
-    .. py:property:: value
-        :type: bitarray.bitarray
-        :no-index:
+        - Assignment accepts either a :class:`bytes` object or a
+          :class:`bitarray.bitarray`.
+        - The returned object can be modified directly, but must be reassigned
+          to take effect.
 
-        Gets or sets the bit string value in **little-endian** form.
+    .. py:method:: clear() -> None
 
-        When setting, you can assign:
+        Clears all bits (sets them to ``0``).
 
-        - a bytes object, which will be converted into a bit array,
-        - a ``bitarray.bitarray`` object directly.
+    .. py:method:: set(bit: int, flag: bool) -> None
 
-    .. py:property:: value_BE
-        :type: bitarray.bitarray
-        :no-index:
+        Sets the given ``bit`` position to ``True`` or ``False``.
 
-        Gets or sets the bit string value in **big-endian** form.
+    .. py:method:: get(bit: int) -> bool
 
-        Supported for **all top-level and named BIT STRING types**.
+        Returns the boolean state of the given ``bit`` position.
 
-Named BIT STRING types will be represented by :class:`_Asn1FlagType`.
+    .. py:method:: size() -> int
 
-Usage Notes
------------
+        Returns the current number of **bytes** in the ``BIT STRING``.
 
-- Bit order within the underlying bit array is **little-endian** aligned by
-  default, meaning bit 0 corresponds to the least significant bit of the
-  first byte.
+    .. py:method:: resize(size: int) -> None
 
-- Named bit strings allow intuitive usage of individual flags:
+        Adjusts the number of **bits** in the ``BIT STRING``.
 
-  .. code-block:: python
 
-      flags = MyFlags()
-      # Keep in mind that in-place operations are not possible
-      flags_value = flags.value
-      flags_value[MyFlags.V_flag1] = 1
 
-      flags.value = flags_value
-      if flags.value[MyFlags.V_flag2]:
-          print("Flag 2 is set")
+Usage Notes
+-----------
 
-- The ``value`` property allows seamless conversion between raw bits
-  and named flags.
+- Unlike integer masks, bits can be manipulated directly using
+  :func:`_Asn1BitStrType.set` and :func:`_Asn1BitStrType.get`.
 
-- Direct modifications to the ``bitarray`` returned by ``value`` or ``value_BE`` do not
-  affect the stored value unless reassigned.
+  .. code-block:: python
 
-.. note:: Endian conversion rules:
+      bs = ExampleBitString(size=8)
+      bs.set(3, True)   # set bit 3
+      print(bs.get(3))  # True
 
-    - **Top-level and named BIT STRING types** support both :code:`.value`
-      (little-endian) and :code:`.value_BE` (big-endian).
-    - **Embedded unnamed BIT STRINGs** (e.g., inline fields inside ``SEQUENCE``
-      or ``SET`` without a type alias) only support little-endian access via
-      :code:`.value`.
+- Named ``BIT STRING`` types provide boolean attributes for each flag:
 
-    .. code-block:: asn1
+  .. code-block:: python
 
-        MyFlags ::= BIT STRING { read(0), write(1) }
+      flags = ExampleNamedBitString()
+      flags.V_one = True
+      if flags.V_one:
+          print("Flag 'one' is set")
 
-        MySeq ::= SEQUENCE {
-            f1 BIT STRING,         -- only little-endian
-            f2 MyFlags             -- supports little-endian and big-endian
-        }
+- For very small ``BIT STRING`` types (≤ 1 byte):
+  If they are encoded using two bytes of space, the queried bit will always be
+  positioned on the **last octet internally**.

_sources/reference/basic/boolean.rst.txt

@@ -1,4 +1,4 @@
-.. _reference_basic_boolean:
+.. _reference_basic_bool:
 
 BOOLEAN
 =======

_sources/reference/basic/time.rst.txt

@@ -1,4 +1,4 @@
-.. _reference_basic_time_types:
+.. _reference_basic_time:
 
 TIME
 ====

_sources/reference/object_model.rst.txt

@@ -17,8 +17,7 @@ value is converted **on-demand** to the corresponding Python object, for example
 - ASN.1 ``INTEGER`` converts to a Python ``int``
 - ASN.1 ``BOOLEAN`` converts to a Python ``bool``
 - ASN.1 ``OCTET STRING`` converts to Python ``bytes``
-- ASN.1 named ``BIT STRING`` converts to an ``enum.IntFlag`` or
-  :class:`bitarray.bitarray`, depending on the type
+- ASN.1 ``BIT STRING`` always generates a new class optionally with named members
 
 This conversion produces a **new** Python object representing the current state.
 

_sources/reference/overview.rst.txt

@@ -433,114 +433,6 @@ All generated Python ENUMERATED classes conform to the following conceptual API:
         If ``None`` is provided, the instance is created in an *unset* state.
 
 
-ASN.1 Conceptual Named BIT STRING Type
---------------------------------------
-
-The ASN.1 ``BIT STRING`` type can be defined with named bit positions, often
-used to represent a set of boolean flags. In the generated Python bindings,
-these named ``BIT STRING`` types are represented by classes that:
-
-- Contain an embedded ``VALUES`` enumeration (a subclass of :class:`enum.IntEnum`).
-- Store their current value internally as a :py:mod:`bitarray.bitarray`.
-- Use **little-endian alignment by default**, while exposing a ``value_BE`` property
-  to query or assign the *big-endian* aligned variant.
-
-.. note::
-    Both ``value`` and ``value_BE`` return the raw :class:`bitarray.bitarray`
-    instance rather than an integer mask or enumeration.
-
-.. warning::
-   Big-endian representation is only available via ``value_BE``. The internal
-   storage is always little-endian. *Big-endian* representation is **not** supported
-   for anonymous inner named ``BIT STRING`` types.
-
-**Example:**
-
-.. code-block:: asn1
-
-    MyFlags ::= BIT STRING {
-        read(0),
-        write(1),
-        execute(2)
-    }
-
-will generate a Python class:
-
-.. code-block:: python
-
-    class MyFlags(_BasicAsn1FlagType):
-        class VALUES(enum.IntFlag):
-            V_read      = 0
-            V_write     = 1
-            V_execute   = 2
-
-Because the generated ``VALUES`` enumeration now stores the **bit position**
-directly (rather than the full mask), checking whether a flag is set is done
-by indexing into the underlying ``bitarray``:
-
-.. code-block:: python
-
-    obj = MyFlags()
-
-    # Check if the 'read' flag is set
-    bool(obj.value[MyFlags.VALUES.V_read])  # True or False
-
-
-All generated Python named BIT STRING classes conform to the following conceptual API:
-
-.. py:class:: _Asn1FlagType
-
-    *Inherits from* :class:`_Asn1Type`.
-
-    Conceptual base class for all ASN.1 named ``BIT STRING`` types.
-
-    .. py:class:: VALUES(enum.IntFlag)
-
-        :text-req:`Required.`
-
-        Inner enumeration containing **all** named flag values defined in the
-        ASN.1 type. Each member is prefixed with ``V_`` to avoid name clashes.
-
-        Each flag's value is the **bit index** in the underlying ``bitarray``.
-
-    .. py:property:: value
-        :type: bitarray.bitarray
-
-        :text-req:`Required.`
-
-        Holds the current flag state as a **little-endian** :class:`bitarray.bitarray`.
-
-        This property accepts assignment using:
-
-        - A :class:`bitarray.bitarray` object (must be little-endian aligned)
-        - A :class:`bytes` object containing the encoded ``BIT STRING``
-
-        Accessing individual flags is done by indexing with a ``VALUES`` member.
-
-        .. warning::
-            Assigning a value containing bits that are not defined in
-            ``VALUES`` will not raise an error, but those bits will be preserved
-            and treated as *unnamed* flags.
-
-    .. py:property:: value_BE
-        :type: bitarray.bitarray
-
-        :text-req:`Required.`
-
-        Holds the current flag state as a **big-endian** :class:`bitarray.bitarray`.
-
-        Similar to ``value``, but the bit ordering is reversed. Assigning or
-        querying this property transparently handles the endian conversion.
-
-
-    .. py:method:: __init__(self, value: _BasicAsn1FlagType.VALUES | int | bytes | bitarray.bitarray | None = None) -> None
-
-        :text-req:`Required.`
-
-        Initializes a new BIT STRING instance with the given value.
-        If ``None`` is provided, the instance is created in an *unset* state.
-
-
 ASN.1 Conceptual CHOICE Type
 ----------------------------