feat: publicly exposed size_of method

Author: MrIndeciso

libdestruct/__init__.py

@@ -19,6 +19,7 @@
 from libdestruct.common.enum import enum, enum_of
 from libdestruct.common.ptr.ptr import ptr
 from libdestruct.common.struct import ptr_to, ptr_to_self, struct
+from libdestruct.common.utils import size_of
 from libdestruct.libdestruct import inflate, inflater
 
 __all__ = [
@@ -41,5 +42,6 @@
     "ptr",
     "ptr_to",
     "ptr_to_self",
+    "size_of",
     "struct",
 ]

libdestruct/common/utils.py

@@ -25,23 +25,33 @@ def is_field_bound_method(item: obj) -> bool:
 
 
 def size_of(item_or_inflater: obj | callable[[Resolver], obj]) -> int:
-    """Return the size of an object, from an obj or it's inflater."""
-    if hasattr(item_or_inflater.__class__, "size"):
-        # This has the priority over the size of the object itself
-        # as we might be dealing with a struct object
-        # that defines an attribute named "size"
-        return item_or_inflater.__class__.size
-    if hasattr(item_or_inflater, "size"):
-        return item_or_inflater.size
-
-    # Check if item is the bound method of a Field
-    if is_field_bound_method(item_or_inflater):
-        field_object = item_or_inflater.__self__
-        return field_object.get_size()
-
-    # Check if item is directly a Field instance
+    """Return the size in bytes of a type, instance, or field descriptor."""
+    # Field instances (e.g. array_of, ptr_to) — must come before .size check
     if isinstance(item_or_inflater, Field):
         return item_or_inflater.get_size()
+    if is_field_bound_method(item_or_inflater):
+        return item_or_inflater.__self__.get_size()
+
+    # Struct types: size is on the inflated _type_impl class
+    if isinstance(item_or_inflater, type) and hasattr(item_or_inflater, "_type_impl"):
+        return item_or_inflater._type_impl.size
+
+    # Struct types not yet inflated: trigger inflation to compute size
+    if isinstance(item_or_inflater, type) and not hasattr(item_or_inflater, "size"):
+        from libdestruct.common.type_registry import TypeRegistry
+
+        impl = TypeRegistry().inflater_for(item_or_inflater)
+        if hasattr(impl, "size") and isinstance(impl.size, int):
+            return impl.size
+
+    # Check class-level size (works for both types and instances)
+    if isinstance(item_or_inflater, type):
+        if hasattr(item_or_inflater, "size") and isinstance(item_or_inflater.size, int):
+            return item_or_inflater.size
+    elif hasattr(item_or_inflater.__class__, "size"):
+        return item_or_inflater.__class__.size
+    elif hasattr(item_or_inflater, "size"):
+        return item_or_inflater.size
 
     raise ValueError(f"Cannot determine the size of {item_or_inflater}")
 

test/scripts/types_unit_test.py

@@ -9,7 +9,7 @@
 import struct as pystruct
 import unittest
 
-from libdestruct import c_int, c_long, c_str, c_uint, c_float, c_double, inflater, struct, ptr, ptr_to_self
+from libdestruct import c_int, c_long, c_str, c_uint, c_float, c_double, inflater, struct, ptr, ptr_to_self, size_of, array_of
 from libdestruct.backing.memory_resolver import MemoryResolver
 
 
@@ -107,7 +107,7 @@ class test_t(struct):
         self.assertIn("0x0", s)
 
     def test_ptr_add(self):
-        """ptr + 1 returns new ptr at addr + sizeof(target)."""
+        """ptr + 1 returns new ptr at addr + size_of(target)."""
         # Array of 3 c_int values: [10, 20, 30]
         memory = bytearray(8 + 12)
         memory[0:8] = (8).to_bytes(8, "little")  # pointer to offset 8
@@ -124,7 +124,7 @@ def test_ptr_add(self):
         self.assertEqual(p3.unwrap().value, 30)
 
     def test_ptr_sub(self):
-        """ptr - 1 returns new ptr at addr - sizeof(target)."""
+        """ptr - 1 returns new ptr at addr - size_of(target)."""
         memory = bytearray(8 + 12)
         memory[0:8] = (12).to_bytes(8, "little")  # pointer to second element
         memory[8:12] = (10).to_bytes(4, "little")
@@ -313,5 +313,45 @@ def test_setitem_middle(self):
         self.assertEqual(s.get(1), b"a")
 
 
+class SizeofTest(unittest.TestCase):
+    """size_of() function."""
+
+    def test_size_of_c_int(self):
+        self.assertEqual(size_of(c_int), 4)
+
+    def test_size_of_c_long(self):
+        self.assertEqual(size_of(c_long), 8)
+
+    def test_size_of_c_float(self):
+        self.assertEqual(size_of(c_float), 4)
+
+    def test_size_of_ptr(self):
+        self.assertEqual(size_of(ptr), 8)
+
+    def test_size_of_struct(self):
+        class two_ints(struct):
+            a: c_int
+            b: c_int
+
+        self.assertEqual(size_of(two_ints), 8)
+
+    def test_size_of_instance(self):
+        obj = c_int.from_bytes((42).to_bytes(4, "little"))
+        self.assertEqual(size_of(obj), 4)
+
+    def test_size_of_array_field(self):
+        self.assertEqual(size_of(array_of(c_int, 10)), 40)
+
+    def test_size_of_nested_struct(self):
+        class inner(struct):
+            x: c_int
+
+        class outer(struct):
+            a: inner
+            b: c_int
+
+        self.assertEqual(size_of(outer), 8)
+
+
 if __name__ == "__main__":
     unittest.main()