patch wchar

Author: ZeroIntensity

src/pointers/c_pointer.py

@@ -10,6 +10,7 @@
     TYPE_CHECKING,
     Union,
     Tuple,
+    Iterator
 )
 from .exceptions import InvalidSizeError
 from _pointers import add_ref, remove_ref
@@ -69,7 +70,7 @@ def _as_parameter_(self):
         return self._address
 
 
-class _BaseCPointer(Pointer[Any]):
+class _BaseCPointer(Pointer[Any], Generic[T]):
     def __init__(self, address: int, size: int):
         super().__init__(address, int, True)
         self._size = size
@@ -79,6 +80,15 @@ def size(self):
         """Size of the pointer."""
         return self._size
 
+    # i need to repeat these for type safety
+    def __iter__(self) -> Iterator[T]:
+        """Dereference the pointer."""
+        return iter({self.dereference()})
+
+    def __invert__(self) -> T:
+        """Dereference the pointer."""
+        return self.dereference()
+
     def _make_stream_and_ptr(
         self,
         data: "_BaseCPointer",
@@ -180,7 +190,7 @@ def __lshift__(self, data: Any):
         return self
 
 
-class VoidPointer(_BaseCPointer):
+class VoidPointer(_BaseCPointer[int]):
     """Class representing a void pointer to a C object."""
 
     @property
@@ -201,28 +211,34 @@ def __rich__(self):
         )
 
 
-class TypedCPointer(_BaseCPointer, Generic[T]):
+class TypedCPointer(_BaseCPointer[T], Generic[T]):
     """Class representing a pointer with a known type."""
 
     def __init__(
         self,
         address: int,
         data_type: Type[T],
         size: int,
+        alternate_method: bool = True
     ):
+        self._alt = alternate_method
         super().__init__(address, size)
         self._type = data_type
 
     @property
-    def _as_parameter_(self):
+    def _as_parameter_(self) -> "ctypes.pointer[ctypes._CData]":
         ctype = self.get_mapped(self.type)
         deref = ctype.from_address(self.address)
         return ctypes.pointer(deref)
 
-    def dereference(self) -> Optional[T]:
+    def dereference(self) -> T:
         """Dereference the pointer."""
         ctype = self.get_mapped(self.type)
-        ptr = ctype.from_address(self.address)
+        ptr = (
+            ctype.from_address(self.address)
+            if not self._alt else
+            ctype(self.address)
+        )
         return ptr.value  # type: ignore
 
     def move(self, data: Pointer, unsafe: bool = False) -> None:
@@ -239,8 +255,11 @@ def __rich__(self):
         return f"<[green]typed c[/green] pointer to [cyan]{hex(self.address)}[/cyan]>"  # noqa
 
     def __del__(self):
-        super().__del__()
-        remove_ref(~self)
+        if self.type is not str:
+            super().__del__()
+            remove_ref(~self)
+
+
 
 
 def cast(ptr: VoidPointer, data_type: Type[T]) -> TypedCPointer[T]:
@@ -251,7 +270,7 @@ def cast(ptr: VoidPointer, data_type: Type[T]) -> TypedCPointer[T]:
 def to_c_ptr(data: T) -> TypedCPointer[T]:
     """Convert a python type to a pointer to a C type."""
     ct = TypedCPointer.map_type(
-        data if not isinstance(data, str) else data.encode(),
+        data,
     )
 
     add_ref(ct)
@@ -260,8 +279,9 @@ def to_c_ptr(data: T) -> TypedCPointer[T]:
 
     return TypedCPointer(
         address,
-        typ if typ is not str else bytes,  # type: ignore
-        ctypes.sizeof(ct)
+        typ,
+        ctypes.sizeof(ct),
+        False
     )
 
 

src/pointers/pointer.py

@@ -130,10 +130,10 @@ def __xor__(self, data: Union["Pointer[T]", T]):
         self.move(_make_ptr(data), unsafe=True)
         return self
 
-    def __del__(self):
+    def __del__(self) -> None:
         remove_ref(~self)
 
-    def __eq__(self, data: object):
+    def __eq__(self, data: object) -> bool:
         if not isinstance(data, Pointer):
             return False