fix: implement caching for dereferenced pointer objects

Author: MrIndeciso

libdestruct/common/ptr/ptr.py

@@ -57,6 +57,8 @@ def __init__(self: ptr, resolver: Resolver, wrapper: type | None = None) -> None
         """
         super().__init__(resolver)
         self.wrapper = wrapper
+        self._cached_unwrap: obj | None = None
+        self._cache_valid: bool = False
 
     def get(self: ptr) -> int:
         """Return the value of the pointer."""
@@ -73,32 +75,47 @@ def to_bytes(self: obj) -> bytes:
     def _set(self: ptr, value: int) -> None:
         """Set the value of the pointer to the given value."""
         self.resolver.modify(self.size, 0, value.to_bytes(self.size, self.endianness))
+        self.invalidate()
+
+    def invalidate(self: ptr) -> None:
+        """Clear the cached unwrap result."""
+        self._cached_unwrap = None
+        self._cache_valid = False
 
     def unwrap(self: ptr, length: int | None = None) -> obj:
         """Return the object pointed to by the pointer.
 
         Args:
             length: The length of the object in memory this points to.
         """
+        if self._cache_valid:
+            return self._cached_unwrap
+
         address = self.get()
 
         if self.wrapper:
             if length:
                 raise ValueError("Length is not supported when unwrapping a pointer to a wrapper object.")
 
-            return self.wrapper(self.resolver.absolute_from_own(address))
-
-        if not length:
-            length = 1
+            result = self.wrapper(self.resolver.absolute_from_own(address))
+        elif not length:
+            result = self.resolver.resolve(1, 0)
+        else:
+            result = self.resolver.resolve(length, 0)
 
-        return self.resolver.resolve(length, 0)
+        self._cached_unwrap = result
+        self._cache_valid = True
+        return result
 
     def try_unwrap(self: ptr, length: int | None = None) -> obj | None:
         """Return the object pointed to by the pointer, if it is valid.
 
         Args:
             length: The length of the object in memory this points to.
         """
+        if self._cache_valid:
+            return self._cached_unwrap
+
         address = self.get()
 
         try:

test/scripts/types_unit_test.py

@@ -174,6 +174,89 @@ def test_ptr_arithmetic_chain(self):
 
         self.assertEqual((p + 2)[0].value, 3)
 
+    def test_unwrap_cached(self):
+        """Two unwrap() calls return the same object."""
+        class test_t(struct):
+            a: c_int
+            p: ptr = ptr_to_self()
+
+        memory = bytearray(12)
+        memory[0:4] = (42).to_bytes(4, "little")
+        memory[4:12] = (0).to_bytes(8, "little")
+
+        lib = inflater(memory)
+        test = lib.inflate(test_t, 0)
+
+        r1 = test.p.unwrap()
+        r2 = test.p.unwrap()
+        self.assertIs(r1, r2)
+
+    def test_invalidate_clears_cache(self):
+        """invalidate() causes next unwrap() to return a new object."""
+        class test_t(struct):
+            a: c_int
+            p: ptr = ptr_to_self()
+
+        memory = bytearray(12)
+        memory[0:4] = (42).to_bytes(4, "little")
+        memory[4:12] = (0).to_bytes(8, "little")
+
+        lib = inflater(memory)
+        test = lib.inflate(test_t, 0)
+
+        r1 = test.p.unwrap()
+        test.p.invalidate()
+        r2 = test.p.unwrap()
+        self.assertIsNot(r1, r2)
+
+    def test_cache_reflects_memory_change(self):
+        """After memory change + invalidate, unwrap gets new value."""
+        class test_t(struct):
+            a: c_int
+            p: ptr = ptr_to_self()
+
+        memory = bytearray(12)
+        memory[0:4] = (42).to_bytes(4, "little")
+        memory[4:12] = (0).to_bytes(8, "little")
+
+        lib = inflater(memory)
+        test = lib.inflate(test_t, 0)
+
+        self.assertEqual(test.p.unwrap().a.value, 42)
+        memory[0:4] = (99).to_bytes(4, "little")
+        test.p.invalidate()
+        self.assertEqual(test.p.unwrap().a.value, 99)
+
+    def test_try_unwrap_cached(self):
+        """try_unwrap() also uses cache."""
+        class test_t(struct):
+            a: c_int
+            p: ptr = ptr_to_self()
+
+        memory = bytearray(12)
+        memory[0:4] = (42).to_bytes(4, "little")
+        memory[4:12] = (0).to_bytes(8, "little")
+
+        lib = inflater(memory)
+        test = lib.inflate(test_t, 0)
+
+        r1 = test.p.try_unwrap()
+        r2 = test.p.try_unwrap()
+        self.assertIs(r1, r2)
+
+    def test_cache_invalidated_on_set(self):
+        """ptr.value = new_addr auto-invalidates the cache."""
+        memory = bytearray(8 + 8)  # ptr + two c_int slots
+        memory[0:8] = (8).to_bytes(8, "little")   # points to offset 8
+        memory[8:12] = (10).to_bytes(4, "little")
+        memory[12:16] = (20).to_bytes(4, "little")
+
+        p = ptr(MemoryResolver(memory, 0), c_int)
+
+        self.assertEqual(p.unwrap().value, 10)
+        p.value = 12  # now points to offset 12
+        self.assertEqual(p.unwrap().value, 20)
+
 
 class FloatTest(unittest.TestCase):
     """c_float and c_double types."""