dissect.cstruct 5.0.dev7__py3-none-any.whl → 5.0.dev9__py3-none-any.whl

dissect/cstruct/types/base.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import functools
+import warnings
 from io import BytesIO
 from typing import TYPE_CHECKING, Any, BinaryIO, ClassVar, TypeVar
 
 from dissect.cstruct.exception import ArraySizeError
 from dissect.cstruct.expression import Expression
+from dissect.cstruct.util import classproperty, normalize_endianness
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -21,17 +23,17 @@ EOF = -0xE0F  # Negative counts are illegal anyway, so abuse that for our EOF se
 class MetaType(type):
     """Base metaclass for cstruct type classes."""
 
-    cs: cstruct
+    __cs__: cstruct
     """The cstruct instance this type class belongs to."""
-    size: int | None
+    __size__: int | None
     """The size of the type in bytes. Can be ``None`` for dynamic sized types."""
-    dynamic: bool
+    __dynamic__: bool
     """Whether or not the type is dynamically sized."""
-    alignment: int | None
+    __alignment__: int | None
     """The alignment of the type in bytes. A value of ``None`` will be treated as 1-byte aligned."""
 
     # This must be the actual type, but since Array is a subclass of BaseType, we correct this at the bottom of the file
-    ArrayType: type[BaseArray] = "Array"
+    __ArrayType__: type[BaseArray] = "Array"
     """The array type for this type class."""
 
     def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
@@ -41,10 +43,12 @@ class MetaType(type):
             stream = args[0]
 
             if _is_readable_type(stream):
-                endian = normalize_endianness(endian) if (endian := kwargs.get("endian")) is not None else cls.cs.endian
+                endian = (
+                    normalize_endianness(endian) if (endian := kwargs.get("endian")) is not None else cls.__cs__.endian
+                )
                 return cls._read(stream, endian=endian)
 
-            if issubclass(cls, bytes) and isinstance(stream, bytes) and len(stream) == cls.size:
+            if issubclass(cls, bytes) and isinstance(stream, bytes) and len(stream) == cls.__size__:
                 # Shortcut for char/bytes type
                 return type.__call__(cls, *args, **kwargs)
 
@@ -55,7 +59,7 @@ class MetaType(type):
 
     def __getitem__(cls, num_entries: int | Expression | None) -> type[BaseArray]:
         """Create a new array with the given number of entries."""
-        return cls.cs._make_array(cls, num_entries)
+        return cls.__cs__._make_array(cls, num_entries)
 
     def __bool__(cls) -> bool:
         """Type class is always truthy."""
@@ -63,10 +67,10 @@ class MetaType(type):
 
     def __len__(cls) -> int:
         """Return the byte size of the type."""
-        if cls.size is None:
+        if cls.__size__ is None:
             raise TypeError("Dynamic size")
 
-        return cls.size
+        return cls.__size__
 
     def __default__(cls) -> Self:  # type: ignore
         """Return the default value of this type."""
@@ -83,7 +87,7 @@ class MetaType(type):
         Returns:
             The parsed value of this type.
         """
-        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        endian = normalize_endianness(endian) if endian is not None else cls.__cs__.endian
         return cls._read(BytesIO(data), endian=endian)
 
     def read(cls, obj: BinaryIO | bytes | memoryview | bytearray, *, endian: AllowedEndianness | None = None) -> Self:  # type: ignore
@@ -103,7 +107,7 @@ class MetaType(type):
         if not _is_readable_type(obj):
             raise TypeError("Invalid object type")
 
-        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        endian = normalize_endianness(endian) if endian is not None else cls.__cs__.endian
         return cls._read(obj, endian=endian)
 
     def write(cls, stream: BinaryIO, value: Any, *, endian: AllowedEndianness | None = None) -> int:
@@ -118,7 +122,7 @@ class MetaType(type):
         Returns:
             The amount of bytes written.
         """
-        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        endian = normalize_endianness(endian) if endian is not None else cls.__cs__.endian
         return cls._write(stream, value, endian=endian)
 
     def dumps(cls, value: Any, *, endian: AllowedEndianness | None = None) -> bytes:
@@ -132,7 +136,7 @@ class MetaType(type):
         Returns:
             The raw bytes of this type.
         """
-        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        endian = normalize_endianness(endian) if endian is not None else cls.__cs__.endian
 
         out = BytesIO()
         cls._write(out, value, endian=endian)
@@ -210,6 +214,56 @@ class MetaType(type):
         """
         return cls._write_array(stream, [*array, cls.__default__()], endian=endian)
 
+    @property
+    def cs(cls) -> cstruct:
+        """Access the cstruct object for this type."""
+        warnings.warn(
+            "The 'cs' property is deprecated, use '__cs__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__cs__
+
+    @property
+    def size(cls) -> int | None:
+        """Access the size of this type."""
+        warnings.warn(
+            "The 'size' property is deprecated, use '__size__', len(cls) or sizeof(cls) instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__size__
+
+    @property
+    def dynamic(cls) -> bool:
+        """Access whether this type is dynamically sized."""
+        warnings.warn(
+            "The 'dynamic' property is deprecated, use '__dynamic__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__dynamic__
+
+    @property
+    def alignment(cls) -> int | None:
+        """Access the alignment of this type."""
+        warnings.warn(
+            "The 'alignment' property is deprecated, use '__alignment__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__alignment__
+
+    @property
+    def ArrayType(cls) -> type[BaseArray]:
+        """Access the array type of this type."""
+        warnings.warn(
+            "The 'ArrayType' property is deprecated, use '__ArrayType__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__ArrayType__
+
 
 class _overload:
     """Descriptor to use on the ``write`` and ``dumps`` methods on cstruct types.
@@ -240,10 +294,10 @@ class BaseType(metaclass=MetaType):
 
     def __len__(self) -> int:
         """Return the byte size of the type."""
-        if self.__class__.size is None:
+        if self.__class__.__size__ is None:
             raise TypeError("Dynamic size")
 
-        return self.__class__.size
+        return self.__class__.__size__
 
 
 T = TypeVar("T", bound=BaseType)
@@ -260,46 +314,76 @@ class BaseArray(BaseType):
             x[expr] -> expr -> dynamic length.
     """
 
-    type: ClassVar[type[BaseType]]
-    num_entries: ClassVar[int | Expression | None]
-    null_terminated: ClassVar[bool]
+    __type__: ClassVar[type[BaseType]]
+    __num_entries__: ClassVar[int | Expression | None]
+    __null_terminated__: ClassVar[bool]
 
     @classmethod
     def __default__(cls) -> BaseType:
         return type.__call__(
-            cls, [cls.type.__default__()] * (cls.num_entries if isinstance(cls.num_entries, int) else 0)
+            cls, [cls.__type__.__default__()] * (cls.__num_entries__ if isinstance(cls.__num_entries__, int) else 0)
         )
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[BaseType]:
-        if cls.null_terminated:
-            return cls.type._read_0(stream, context=context, endian=endian)
+        if cls.__null_terminated__:
+            return cls.__type__._read_0(stream, context=context, endian=endian)
 
-        if isinstance(cls.num_entries, int):
-            num = max(0, cls.num_entries)
-        elif cls.num_entries is None:
+        if isinstance(cls.__num_entries__, int):
+            num = max(0, cls.__num_entries__)
+        elif cls.__num_entries__ is None:
             num = EOF
-        elif isinstance(cls.num_entries, Expression):
+        elif isinstance(cls.__num_entries__, Expression):
             try:
-                num = max(0, cls.num_entries.evaluate(cls.cs, context))
+                num = max(0, cls.__num_entries__.evaluate(cls.__cs__, context))
             except Exception:
-                if cls.num_entries.expression != "EOF":
+                if cls.__num_entries__.expression != "EOF":
                     raise
                 num = EOF
 
-        return cls.type._read_array(stream, num, context=context, endian=endian)
+        return cls.__type__._read_array(stream, num, context=context, endian=endian)
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: list[Any], *, endian: Endianness) -> int:
-        if cls.null_terminated:
-            return cls.type._write_0(stream, data, endian=endian)
+        if cls.__null_terminated__:
+            return cls.__type__._write_0(stream, data, endian=endian)
 
-        if not cls.dynamic and (remaining := cls.num_entries - (actual_size := len(data))):
+        if not cls.__dynamic__ and (remaining := cls.__num_entries__ - (actual_size := len(data))):
             if remaining < 0:
-                raise ArraySizeError(f"Expected static array size {cls.num_entries}, got {actual_size} instead.")
-            data = data + [cls.type.__default__()] * remaining
-
-        return cls.type._write_array(stream, data, endian=endian)
+                raise ArraySizeError(f"Expected static array size {cls.__num_entries__}, got {actual_size} instead.")
+            data = data + [cls.__type__.__default__()] * remaining
+
+        return cls.__type__._write_array(stream, data, endian=endian)
+
+    @classproperty
+    def type(cls) -> type[BaseType]:
+        """Access the array element type."""
+        warnings.warn(
+            "The 'type' property is deprecated, use '__type__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__type__
+
+    @classproperty
+    def num_entries(cls) -> int | Expression | None:
+        """Access the number of entries for this array type."""
+        warnings.warn(
+            "The 'num_entries' property is deprecated, use '__num_entries__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__num_entries__
+
+    @classproperty
+    def null_terminated(cls) -> bool:
+        """Access whether this array type is null-terminated."""
+        warnings.warn(
+            "The 'null_terminated' property is deprecated, use '__null_terminated__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__null_terminated__
 
 
 class Array(list[T], BaseArray):
@@ -328,27 +412,5 @@ def _is_eof(stream: BinaryIO) -> bool:
     return False
 
 
-ENDIANNESS_MAP: dict[AllowedEndianness, Endianness] = {
-    "<": "<",
-    ">": ">",
-    "!": "!",
-    "@": "@",
-    "=": "=",
-    "network": "!",
-    "little": "<",
-    "big": ">",
-}
-
-
-def normalize_endianness(endian: AllowedEndianness) -> Endianness:
-    """Normalize an endianness string to one of the standard format characters."""
-    try:
-        return ENDIANNESS_MAP[endian]
-    except KeyError:
-        raise ValueError(
-            f"Invalid endianness: {endian!r}, expected one of {', '.join(ENDIANNESS_MAP.keys())}"
-        ) from None
-
-
 # As mentioned in the BaseType class, we correctly set the type here
-MetaType.ArrayType = Array
+MetaType.__ArrayType__ = Array

dissect/cstruct/types/char.py

@@ -16,7 +16,7 @@ class CharArray(bytes, BaseArray):
 
     @classmethod
     def __default__(cls) -> Self:
-        return type.__call__(cls, b"\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
+        return type.__call__(cls, b"\x00" * (0 if cls.__dynamic__ or cls.__null_terminated__ else cls.__num_entries__))
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
@@ -29,12 +29,12 @@ class CharArray(bytes, BaseArray):
         elif isinstance(data, str):
             data = data.encode("latin-1")
 
-        if cls.null_terminated:
+        if cls.__null_terminated__:
             data += b"\x00"
 
-        if not cls.dynamic and (remaining := cls.num_entries - (actual_size := len(data))):
+        if not cls.__dynamic__ and (remaining := cls.__num_entries__ - (actual_size := len(data))):
             if remaining < 0:
-                raise ArraySizeError(f"Expected static array size {cls.num_entries}, got {actual_size} instead.")
+                raise ArraySizeError(f"Expected static array size {cls.__num_entries__}, got {actual_size} instead.")
             data += b"\x00" * remaining
 
         return stream.write(data)
@@ -43,7 +43,7 @@ class CharArray(bytes, BaseArray):
 class Char(bytes, BaseType):
     """Character type for reading and writing bytes."""
 
-    ArrayType = CharArray
+    __ArrayType__ = CharArray
 
     @classmethod
     def __default__(cls) -> Self:

dissect/cstruct/types/enum.py

@@ -21,7 +21,7 @@ _S = TypeVar("_S")
 
 
 class EnumMetaType(EnumMeta, MetaType):
-    type: type[BaseType]
+    __type__: type[BaseType]
 
     @overload
     def __call__(cls, value: cstruct, name: str, type_: type[BaseType], *args, **kwargs) -> type[Enum]: ...
@@ -39,11 +39,11 @@ class EnumMetaType(EnumMeta, MetaType):
     ) -> Enum | type[Enum]:
         if name is None:
             if value is None:
-                value = cls.type.__default__()
+                value = cls.__type__.__default__()
 
             if not isinstance(value, int):
                 # value is a parsable value
-                value = cls.type(value)
+                value = cls.__type__(value)
 
             return super().__call__(value)
 
@@ -54,11 +54,11 @@ class EnumMetaType(EnumMeta, MetaType):
             raise TypeError("Enum can only be created from int type")
 
         enum_cls = super().__call__(name, *args, **kwargs)
-        enum_cls.cs = cs
-        enum_cls.type = type_
-        enum_cls.size = type_.size
-        enum_cls.dynamic = type_.dynamic
-        enum_cls.alignment = type_.alignment
+        enum_cls.__cs__ = cs
+        enum_cls.__type__ = type_
+        enum_cls.__size__ = type_.__size__
+        enum_cls.__dynamic__ = type_.__dynamic__
+        enum_cls.__alignment__ = type_.__alignment__
 
         _fix_alias_members(enum_cls)
 
@@ -85,26 +85,26 @@ class EnumMetaType(EnumMeta, MetaType):
         return value in cls._value2member_map_
 
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
-        return cls(cls.type._read(stream, context=context, endian=endian))
+        return cls(cls.__type__._read(stream, context=context, endian=endian))
 
     def _read_array(
         cls, stream: BinaryIO, count: int, *, context: dict[str, Any] | None = None, endian: Endianness
     ) -> list[Self]:
-        return list(map(cls, cls.type._read_array(stream, count, context=context, endian=endian)))
+        return list(map(cls, cls.__type__._read_array(stream, count, context=context, endian=endian)))
 
     def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:
-        return list(map(cls, cls.type._read_0(stream, context=context, endian=endian)))
+        return list(map(cls, cls.__type__._read_0(stream, context=context, endian=endian)))
 
     def _write(cls, stream: BinaryIO, data: Enum, *, endian: Endianness) -> int:
-        return cls.type._write(stream, data.value, endian=endian)
+        return cls.__type__._write(stream, data.value, endian=endian)
 
     def _write_array(cls, stream: BinaryIO, array: list[BaseType | int], *, endian: Endianness) -> int:
         data = [entry.value if isinstance(entry, _Enum) else entry for entry in array]
-        return cls.type._write_array(stream, data, endian=endian)
+        return cls.__type__._write_array(stream, data, endian=endian)
 
     def _write_0(cls, stream: BinaryIO, array: list[BaseType | int], *, endian: Endianness) -> int:
         data = [entry.value if isinstance(entry, _Enum) else entry for entry in array]
-        return cls._write_array(stream, [*data, cls.type.__default__()], endian=endian)
+        return cls._write_array(stream, [*data, cls.__type__.__default__()], endian=endian)
 
     def cdef(cls) -> str:
         """Render this enum (or flag) back to its C-style definition.
@@ -113,7 +113,7 @@ class EnumMetaType(EnumMeta, MetaType):
             The C-style definition as a string.
         """
         keyword = "flag" if issubclass(cls, IntFlag) else "enum"
-        underlying = cls.type.__name__
+        underlying = cls.__type__.__name__
         title = f"{keyword} {cls.__name__} : {underlying}" if cls.__name__ else f"{keyword} : {underlying}"
 
         lines = [f"{title} {{"]

dissect/cstruct/types/int.py

@@ -18,10 +18,10 @@ class Int(int, BaseType):
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
-        data = stream.read(cls.size)
+        data = stream.read(cls.__size__)
 
-        if len(data) != cls.size:
-            raise EOFError(f"Read {len(data)} bytes, but expected {cls.size}")
+        if len(data) != cls.__size__:
+            raise EOFError(f"Read {len(data)} bytes, but expected {cls.__size__}")
 
         return cls.from_bytes(data, ENDIANNESS_TO_BYTEORDER_MAP[endian], signed=cls.signed)
 
@@ -39,4 +39,4 @@ class Int(int, BaseType):
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: int, *, endian: Endianness) -> int:
-        return stream.write(data.to_bytes(cls.size, ENDIANNESS_TO_BYTEORDER_MAP[endian], signed=cls.signed))
+        return stream.write(data.to_bytes(cls.__size__, ENDIANNESS_TO_BYTEORDER_MAP[endian], signed=cls.signed))

dissect/cstruct/types/packed.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from functools import lru_cache
-from struct import Struct
+import warnings
 from typing import TYPE_CHECKING, Any, BinaryIO, Generic, TypeVar
 
 from dissect.cstruct.types.base import EOF, BaseType
+from dissect.cstruct.util import _struct, classproperty
 
 if TYPE_CHECKING:
     from typing_extensions import Self
@@ -12,27 +12,22 @@ if TYPE_CHECKING:
     from dissect.cstruct.cstruct import Endianness
 
 
-@lru_cache(1024)
-def _struct(endian: str, packchar: str) -> Struct:
-    return Struct(f"{endian}{packchar}")
-
-
 T = TypeVar("T", int, float)
 
 
 class Packed(BaseType, Generic[T]):
     """Packed type for Python struct (un)packing."""
 
-    packchar: str
+    __fmt__: str
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
-        data = stream.read(cls.size)
+        data = stream.read(cls.__size__)
 
-        if len(data) != cls.size:
-            raise EOFError(f"Read {len(data)} bytes, but expected {cls.size}")
+        if len(data) != cls.__size__:
+            raise EOFError(f"Read {len(data)} bytes, but expected {cls.__size__}")
 
-        return cls.__new__(cls, _struct(endian, cls.packchar).unpack(data)[0])
+        return cls.__new__(cls, _struct(endian, cls.__fmt__).unpack(data)[0])
 
     @classmethod
     def _read_array(
@@ -41,12 +36,12 @@ class Packed(BaseType, Generic[T]):
         if count == EOF:
             data = stream.read()
             length = len(data)
-            count = length // cls.size
+            count = length // cls.__size__
         else:
-            length = cls.size * count
+            length = cls.__size__ * count
             data = stream.read(length)
 
-        fmt = _struct(endian, f"{count}{cls.packchar}")
+        fmt = _struct(endian, f"{count}{cls.__fmt__}")
 
         if len(data) != length:
             raise EOFError(f"Read {len(data)} bytes, but expected {length}")
@@ -57,12 +52,12 @@ class Packed(BaseType, Generic[T]):
     def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None, *, endian: Endianness) -> Self:
         result = []
 
-        fmt = _struct(endian, cls.packchar)
+        fmt = _struct(endian, cls.__fmt__)
         while True:
-            data = stream.read(cls.size)
+            data = stream.read(cls.__size__)
 
-            if len(data) != cls.size:
-                raise EOFError(f"Read {len(data)} bytes, but expected {cls.size}")
+            if len(data) != cls.__size__:
+                raise EOFError(f"Read {len(data)} bytes, but expected {cls.__size__}")
 
             if (value := fmt.unpack(data)[0]) == 0:
                 break
@@ -73,8 +68,18 @@ class Packed(BaseType, Generic[T]):
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: Packed[T], *, endian: Endianness) -> int:
-        return stream.write(_struct(endian, cls.packchar).pack(data))
+        return stream.write(_struct(endian, cls.__fmt__).pack(data))
 
     @classmethod
     def _write_array(cls, stream: BinaryIO, data: list[Packed[T]], *, endian: Endianness) -> int:
-        return stream.write(_struct(endian, f"{len(data)}{cls.packchar}").pack(*data))
+        return stream.write(_struct(endian, f"{len(data)}{cls.__fmt__}").pack(*data))
+
+    @classproperty
+    def packchar(cls) -> str:
+        """Access the struct packing character of packed integer/float types."""
+        warnings.warn(
+            "The 'packchar' property is deprecated, use '__fmt__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__fmt__

dissect/cstruct/types/pointer.py

@@ -21,23 +21,23 @@ T = TypeVar("T", bound=BaseType)
 class Pointer(int, BaseType, Generic[T]):
     """Pointer to some other type."""
 
-    type: type[T]
-    _stream: BinaryIO | None
-    _context: dict[str, Any] | None
-    _endian: Endianness
+    __type__: type[T]
+    __stream: BinaryIO | None
+    __context: dict[str, Any] | None
+    __endian: Endianness
 
     def __new__(
         cls, value: int, stream: BinaryIO | None, *, context: dict[str, Any] | None = None, endian: Endianness
     ) -> Self:
         obj = super().__new__(cls, value)
-        obj._stream = stream
-        obj._context = context
-        obj._endian = endian
+        obj.__stream = stream
+        obj.__context = context
+        obj.__endian = endian
         obj.dereference = cache(obj.dereference)
         return obj
 
     def __repr__(self) -> str:
-        return f"<{self.type.__name__}* @ {self:#x}>"
+        return f"<{self.__type__.__name__}* @ {self:#x}>"
 
     def __str__(self) -> str:
         return str(self.dereference())
@@ -51,9 +51,9 @@ class Pointer(int, BaseType, Generic[T]):
             return type.__call__(
                 self.__class__,
                 op(self, other),
-                self._stream,
-                context=self._context,
-                endian=self._endian,
+                self.__stream,
+                context=self.__context,
+                endian=self.__endian,
             )
 
         return method
@@ -74,17 +74,17 @@ class Pointer(int, BaseType, Generic[T]):
     def __default__(cls) -> Self:
         return cls.__new__(
             cls,
-            cls.cs.pointer.__default__(),
+            cls.__cs__.pointer.__default__(),
             None,
             context=None,
-            endian=cls.cs.endian,
+            endian=cls.__cs__.endian,
         )
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         return cls.__new__(
             cls,
-            cls.cs.pointer._read(stream, context=context, endian=endian),
+            cls.__cs__.pointer._read(stream, context=context, endian=endian),
             stream,
             context=context,
             endian=endian,
@@ -92,7 +92,7 @@ class Pointer(int, BaseType, Generic[T]):
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: int, *, endian: Endianness) -> int:
-        return cls.cs.pointer._write(stream, data, endian=endian)
+        return cls.__cs__.pointer._write(stream, data, endian=endian)
 
     def dereference(self, *, endian: AllowedEndianness | None = None) -> T | None:
         """Dereference the pointer and read the value it points to.
@@ -101,22 +101,22 @@ class Pointer(int, BaseType, Generic[T]):
             endian: Optional endianness to use when reading the value.
                     If not provided, the endianness used when reading the pointer itself will be used.
         """
-        if self == 0 or self._stream is None:
+        if self == 0 or self.__stream is None:
             raise NullPointerDereference
 
-        endian = normalize_endianness(endian) if endian is not None else self._endian
-        if issubclass(self.type, Void):
+        endian = normalize_endianness(endian) if endian is not None else self.__endian
+        if issubclass(self.__type__, Void):
             return None
 
-        position = self._stream.tell()
-        self._stream.seek(self)
+        position = self.__stream.tell()
+        self.__stream.seek(self)
 
-        if issubclass(self.type, Char):
+        if issubclass(self.__type__, Char):
             # This makes the assumption that a char pointer is a null-terminated string
-            value = self.type._read_0(self._stream, context=self._context, endian=endian)
+            value = self.__type__._read_0(self.__stream, context=self.__context, endian=endian)
         else:
-            value = self.type._read(self._stream, context=self._context, endian=endian)
+            value = self.__type__._read(self.__stream, context=self.__context, endian=endian)
 
         # Restore the stream position after reading the value
-        self._stream.seek(position)
+        self.__stream.seek(position)
         return value