import ctypes

import sys

from typing import TypeVar, Union

from _pointers import add_ref, remove_ref, set_ref

from .base_pointers import NULL, BaseObjectPointer, BasePointer, Nullable

from .exceptions import InvalidSizeError

from .util import handle

T = TypeVar("T")

class Pointer(BaseObjectPointer[T]):

"""Pointer to a `PyObject`"""

def __repr__(self) -> str:

return f"Pointer(address={self.address})"

@handle

def move(

self,

target: Union[T, "BasePointer[T]"],

*,

unsafe: bool = False,

):

data = target if isinstance(target, BasePointer) else to_ptr(target)

if not isinstance(data, BaseObjectPointer):

raise ValueError(

"pointer is not pointing to an object",

)

deref_a: T = ~data # type: ignore

deref_b: T = ~self

size_a: int = sys.getsizeof(deref_a)

size_b: int = sys.getsizeof(deref_b)

refcnt = sys.getrefcount(deref_b)

refcnt_a = sys.getrefcount(deref_a)

if (self._origin_size < size_a) and (not unsafe):

raise InvalidSizeError(

f"target size may not exceed current size ({size_a} < {size_b})", # noqa

)

if type(deref_a) is not type(deref_b):

raise TypeError(

"cannot move object of a different type",

)

current_address: int = self.ensure()

bytes_a = (ctypes.c_ubyte * size_a).from_address(data.ensure())

bytes_b = (ctypes.c_ubyte * size_b).from_address(current_address)

self.assign(~data)

ctypes.memmove(bytes_b, bytes_a, len(bytes_a))

set_ref(deref_b, (refcnt - 1) + (refcnt_a - 2))

@classmethod

def make_from(cls, obj: Nullable[T]) -> "Pointer[T]":

is_null = obj is NULL

return Pointer(

id(obj) if not is_null else None,

not is_null,

)

@handle

def to_ptr(obj: Nullable[T]) -> Pointer[T]:

"""Point to the underlying `PyObject`.

Args:

obj: Object to point to.

Returns:

Created pointer.

Example:

```py

ptr = to_ptr(1) # ptr now points to 1

something = 2

something_ptr = to_ptr(something) # points to 2, not "something"

```

"""

add_ref(obj)

ptr = Pointer.make_from(obj)

remove_ref(obj)

return ptr