feat: add linear constant-size array implementation

Additionally, fix some typing issues

Author: MrIndeciso

libdestruct/__init__.py

@@ -13,7 +13,8 @@
 
 from libdestruct.c import c_int, c_long, c_str, c_uint, c_ulong
 from libdestruct.common import ptr
+from libdestruct.common.array import array, array_of
 from libdestruct.common.struct import ptr_to, ptr_to_self, struct
 from libdestruct.libdestruct import inflater
 
-__all__ = ["c_int", "c_long", "c_str", "c_uint", "c_ulong", "inflater", "struct", "ptr", "ptr_to", "ptr_to_self"]
+__all__ = ["array", "array_of", "c_int", "c_long", "c_str", "c_uint", "c_ulong", "inflater", "struct", "ptr", "ptr_to", "ptr_to_self"]

libdestruct/c/c_str.py

@@ -7,10 +7,9 @@
 from __future__ import annotations
 
 from libdestruct.common.array.array import array
-from libdestruct.common.obj import obj
 
 
-class c_str(obj, array):
+class c_str(array):
     """A C string."""
 
     def size(self: c_str) -> int:
@@ -35,7 +34,7 @@ def get(self: c_str, index: int = -1) -> bytes:
 
         return bytes([self.memory[self.address + index]])
 
-    def to_bytes(self: obj) -> bytes:
+    def to_bytes(self: c_str) -> bytes:
         """Return the serialized representation of the object."""
         return self.memory[self.address : self.address + self.size()]
 

libdestruct/common/array/__init__.py

@@ -0,0 +1,12 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from libdestruct.common.array.array import array
+from libdestruct.common.array.array_of import array_of
+
+__all__ = ["array", "array_of"]
+
+import libdestruct.common.array.array_field_inflater  # noqa: F401

libdestruct/common/array/arr_impl.py

@@ -6,10 +6,12 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 
+from libdestruct.common.obj import obj
 
-class array(ABC):
+
+class array(obj):
     """An array of objects."""
 
     @abstractmethod

libdestruct/common/array/array.py

@@ -0,0 +1,29 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSequence
+
+    from libdestruct.common.array import array
+    from libdestruct.common.obj import obj
+
+
+class ArrayField(ABC):
+    """A generator for an array of items."""
+
+    @abstractmethod
+    def inflate(self: ArrayField, memory: MutableSequence, address: int | tuple[obj, int]) -> array:
+        """Inflate the field.
+
+        Args:
+            memory: The backing memory view.
+            address: The address of the field in the memory view.
+        """

libdestruct/common/array/array_field.py

@@ -0,0 +1,37 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.array.linear_array_field import LinearArrayField
+from libdestruct.common.struct.struct import struct
+from libdestruct.common.struct.struct_impl import struct_impl
+from libdestruct.common.type_registry import TypeRegistry
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, MutableSequence
+
+    from libdestruct.common.obj import obj
+
+registry = TypeRegistry()
+
+
+def linear_array_field_inflater(
+    field: LinearArrayField,
+    _: type[obj],
+    __: tuple[obj, type[obj]] | None,
+) -> Callable[[MutableSequence, int | tuple[obj, int]], obj]:
+    """Returns the inflater for an array field of a struct."""
+    if issubclass(field.item, struct) and not issubclass(field.item, struct_impl):
+        field.item = registry.inflater_for(field.item)
+
+    return field.inflate
+
+
+registry.register_instance_handler(LinearArrayField, linear_array_field_inflater)

libdestruct/common/array/array_field_inflater.py

@@ -0,0 +1,81 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.array.array import array
+from libdestruct.common.obj import obj
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, MutableSequence
+
+    from libdestruct.common.obj import obj
+
+
+class array_impl(array):
+    """A linear sequential array."""
+
+    size: int
+    """The size of the array."""
+
+    def __init__(
+        self: array_impl,
+        memory: MutableSequence,
+        address: int | tuple[obj, int],
+        backing_type: obj,
+        count: int,
+    ) -> None:
+        """Initialize the array."""
+        self.memory = memory
+        self.backing_type = backing_type
+        self.count = count
+
+        if isinstance(address, tuple):
+            self._address = None
+            self._reference = address[0]
+            self._offset = address[1]
+        else:
+            self._address = address
+
+        self.size = self.backing_type.size * self.count
+
+    def size(self: array_impl) -> int:
+        """Get the size of the array."""
+        return self.size
+
+    def get(self: array_impl) -> str:
+        """Get the array as a string."""
+        return f"[{', '.join(str(i) for i in self)}]"
+
+    def _set(self: array_impl, _: list[obj]) -> None:
+        """Set the array from a list."""
+        raise NotImplementedError("Cannot set items in an array.")
+
+    def set(self: array_impl, _: list[obj]) -> None:
+        """Set the array from a list."""
+        raise NotImplementedError("Cannot set items in an array.")
+
+    def to_bytes(self: array_impl) -> bytes:
+        """Return the serialized representation of the array."""
+        return b"".join(x for x in self)
+
+    def __getitem__(self: array_impl, index: int) -> obj:
+        """Get an item from the array."""
+        if self._address:
+            return self.backing_type(self.memory, (self._address, index * self.backing_type.size))
+
+        return self.backing_type(self.memory, (self._reference, self._offset + index * self.backing_type.size))
+
+    def __setitem__(self: array_impl, index: int, value: obj) -> None:
+        """Set an item in the array."""
+        raise NotImplementedError("Cannot set items in an array.")
+
+    def __iter__(self: array_impl) -> Generator[obj, None, None]:
+        """Iterate over the array."""
+        for i in range(self.count):
+            yield self[i]

libdestruct/common/array/array_impl.py

@@ -0,0 +1,20 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.array.linear_array_field import LinearArrayField
+
+if TYPE_CHECKING:
+    from libdestruct.common.array.array_field import ArrayField
+    from libdestruct.common.obj import obj
+
+
+def array_of(item: type[obj], size: int) -> ArrayField:
+    """Create an array of items."""
+    return LinearArrayField(item, size)

libdestruct/common/array/array_of.py

@@ -0,0 +1,34 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.array.array_field import ArrayField
+from libdestruct.common.array.array_impl import array_impl
+
+if TYPE_CHECKING:
+    from libdestruct.common.array.array import array
+    from libdestruct.common.obj import obj
+
+
+class LinearArrayField(ArrayField):
+    """A generator for an array of items."""
+
+    def __init__(self: LinearArrayField, item: type[obj], size: int) -> None:
+        """Initialize the field."""
+        self.item = item
+        self.size = size
+
+    def inflate(self: LinearArrayField, memory: list, address: int | tuple[obj, int]) -> array:
+        """Inflate the field.
+
+        Args:
+            memory: The backing memory view.
+            address: The address of the field in the memory view.
+        """
+        return array_impl(memory, address, self.item, self.size)