feat: add support for ctypes

Author: MrIndeciso

libdestruct/c/__init__.py

@@ -10,3 +10,4 @@
 __all__ = ["c_char", "c_uchar", "c_short", "c_ushort", "c_int", "c_uint", "c_long", "c_ulong", "c_str"]
 
 import libdestruct.c.base_type_inflater  # noqa: F401
+import libdestruct.c.ctypes_generic_field  # noqa: F401

libdestruct/c/ctypes_generic.py

@@ -0,0 +1,39 @@
+#
+# 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 Any
+
+from libdestruct.common.obj import obj
+
+
+class _ctypes_generic(obj):
+    """A generic holder for a ctypes object."""
+
+    size: int
+    """The size of the type in bytes."""
+
+    _frozen_value: bytes | None = None
+    """The frozen value of the type."""
+
+    backing_type: type
+    """The backing ctypes object."""
+
+    def get(self: _ctypes_generic) -> Any:
+        """Return the value of the type."""
+        return self.backing_type.from_buffer_copy(self.resolver.resolve(self.size, 0)).value
+
+    def _set(self: _ctypes_generic, value: Any) -> None:
+        """Set the value of the type to the given value."""
+        self.resolver.modify(self.size, 0, bytes(self.backing_type(value)))
+
+    def to_bytes(self: _ctypes_generic) -> bytes:
+        """Serialize the type to bytes."""
+        if self._frozen:
+            return bytes(self._frozen_value)
+
+        return self.resolver.resolve(self.size, 0)

libdestruct/c/ctypes_generic_field.py

@@ -0,0 +1,31 @@
+#
+# 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 ctypes import _SimpleCData, sizeof
+
+from libdestruct.c.ctypes_generic import _ctypes_generic
+from libdestruct.common.type_registry import TypeRegistry
+
+
+def ctypes_type_handler(obj_type: type) -> type[_ctypes_generic]:
+    """Return the ctypes type handler for the given object type.
+
+    Args:
+        obj_type: The object type to handle.
+    """
+    if not issubclass(obj_type, _SimpleCData):
+        raise TypeError(f"Unsupported object type: {obj_type}.")
+
+    return type(
+        f"ctypes_{obj_type.__name__}",
+        (_ctypes_generic,),
+        {"backing_type": obj_type, "size": sizeof(obj_type)},
+    )
+
+
+TypeRegistry().register_type_handler(_SimpleCData, ctypes_type_handler)

libdestruct/common/type_registry.py

@@ -10,7 +10,7 @@
 
 from libdestruct.common.field import Field
 
-if TYPE_CHECKING: # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from collections.abc import Callable
 
     from typing_extensions import Self
@@ -25,7 +25,7 @@ class TypeRegistry:
     mapping: dict[type[obj], type[obj]]
     """The mapping of object types to their implementations."""
 
-    type_handlers: dict[type[obj], list[Callable[[type[obj]], type[obj] | None]]]
+    type_handlers: dict[type, list[Callable[[type[obj]], type[obj] | None]]]
     """The handlers for generic object types, with basic inheritance support."""
 
     instance_handlers: dict[