o i+/@sdZddlZddlmZddlmZddlmZmZm Z ddl m Z m Z ddl mZmZmZmZmZmZmZmZmZddlmZGd d d Zd d Zd dZddZddZddZeddZGdddZ eej!ej"ej"ddZ#dS)zUtilities for defining a mutable struct. A mutable struct is passed by reference; hence, structref (a reference to a struct). N)create_struct_proxy)njit)typesimputilscgutils)default_managermodels) infer_getattrlower_getattr_genericlower_setattr_generic lower_builtinboxunbox NativeValue intrinsicoverload)AttributeTemplatec@s8eZdZdZddZddZddZdd Zd d Zd S) _Utilsz;Internal builder-code utils for structref definitions. cCs||_||_||_dS)z Parameters ---------- context : a numba target context builder : a llvmlite IRBuilder struct_type : numba.core.types.StructRef N)contextbuilder struct_type)selfrrrrZ/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/numba/experimental/structref.py__init__s  z_Utils.__init__cCs,|j}|j}|j}t|||}||_|S)zKEncapsulate the MemInfo from a `StructRefPayload` in a `StructRef` )rrrrrmeminfo)rmirrrstrrrnew_struct_ref+s z_Utils.new_struct_refcCs&|j}|j}|j}t||||dS)z6Return a helper for accessing a StructRefType value)rrrrr)rvalrrrrrrget_struct_ref6s z_Utils.get_struct_refc Cs^|j}|j}|j}||}|j}|j||}|}|j|} | } | || }|S)zDGet the data pointer to the payload from a `StructRefType`. ) rrrr"rnrt meminfo_data get_data_typedata_model_managerget_value_typebitcast as_pointer) rr!rrr structvalrdata_ptrvaltypemodel alloc_typerrrget_data_pointerAs  z_Utils.get_data_pointercCs<|j}|j}|j}||}|}t||||d}|S)zFGet a getter/setter helper for accessing a `StructRefPayload` )ref)rrrr/r%rr)rr!rrrr+r,datavalrrrget_data_structRs z_Utils.get_data_structN) __name__ __module__ __qualname____doc__rrr"r/r2rrrrrs  rcs<tGfdddt}tdd}tdd}dS)zDefine attributes on `struct_typeclass`. Defines both setters and getters in jit-code. This is called directly in `register()`. cseZdZZddZdS)z*define_attributes..StructAttributecSs||jvr |j|}|SdSN) field_dict)rtypattrattrtyrrrgeneric_resolvels  z:define_attributes..StructAttribute.generic_resolveN)r3r4r5keyr<rstruct_typeclassrrStructAttributehs r@c Ss:t|||}||}t||}|j|}t||||Sr7)rr2getattrr8rimpl_ret_borrowed) rrr9r!r:utilsr1ret fieldtyperrrstruct_getattr_implqs    z.define_attributes..struct_getattr_implcSs||j\}}|\}}t|||} | |} |j|} ||||| } t| |} |j||| |j||| t | || dSr7) argsrr2r8castrAr#increfdecrefsetattr)rrsigrGr: inst_typeval_typeinstancer!rCr1 field_typecasted old_valuerrrstruct_setattr_implys     z.define_attributes..struct_setattr_implN)r rr r )r?r@rFrSrr>rdefine_attributesas  rTcsH|tjur tdtj|jt|fdd}t|dd}dS)aDefine the boxing & unboxing logic for `struct_type` to `obj_class`. Defines both boxing and unboxing. - boxing turns an instance of `struct_type` into a PyObject of `obj_class` - unboxing turns an instance of `obj_class` into an instance of `struct_type` in jit-code. Use this directly instead of `define_proxy()` when the user does not want any constructor to be defined. cannot register c st|j|j|}||}|j}ttj}|||}|j |j }|j |j |} |j || |g} |j ||j | |j || S)z8 Convert a raw pointer to a Python int. )rrrr"rrMemInfoPointervoidptrr pyapi unserializeserialize_objectcall_function_objargsrJ) r9r!crC struct_refrmip_type boxed_meminfo ctor_pyfuncty_pyobjresobj_ctorrrbox_struct_refs      z%define_boxing..box_struct_refc Ss^|j|d}ttj}|||j}t|j|j |}| |}| }|j |t |S)N_meminfo)rXobject_getattr_stringrrVrWrr rrrr _getvaluerJr) r9objr\mi_objr^rrCr]outrrrunbox_struct_refs   z'define_boxing..unbox_struct_refN)r StructRef ValueError _numba_box_r r)r obj_classrerlrrcr define_boxings rqc Csd|}d}g}|D] }|d|d|q d||}d|dt|d|d |d |d }t|td } t|| | d } t|| dS)zDefine the jit-code constructor for `struct_typeclass` using the Python type `py_class` and the required `fields`. Use this instead of `define_proxy()` if the user does not want boxing logic defined. z, z zst.z =  z def ctor(z/): struct_type = struct_typeclass(list(zip(z, [z]))) def impl(z)): st = new(struct_type) z# return st return impl )r?newctorN)joinappendlistdictrsexecr) py_classr?fieldsparamsindentinit_fields_bufk init_fieldssourceglbsrtrrrdefine_constructors*  rcCst|||t||dS)aDefines a PyObject proxy for a structref. This makes `py_class` a valid constructor for creating a instance of `struct_typeclass` that contains the members as defined by `fields`. Parameters ---------- py_class : type The Python class for constructing an instance of `struct_typeclass`. struct_typeclass : numba.core.types.Type The structref type class to bind to. fields : Sequence[str] A sequence of field names. Returns ------- None N)rrq)rzr?r{rrr define_proxys rcCs4|tjur tdtjt|tjt||S)aRegister a `numba.core.types.StructRef` for use in jit-code. This defines the data-model for lowering an instance of `struct_type`. This defines attributes accessor and mutator for an instance of `struct_type`. Parameters ---------- struct_type : type A subclass of `numba.core.types.StructRef`. Returns ------- struct_type : type Returns the input argument so this can act like a decorator. Examples -------- .. code-block:: class MyStruct(numba.core.types.StructRef): ... # the simplest subclass can be empty numba.experimental.structref.register(MyStruct) rU)rrmrnrregisterrStructRefModelrT)rrrrrs rcs0ddlm|jfdd}|}||fS)anew(struct_type) A jit-code only intrinsic. Used to allocate an **empty** mutable struct. The fields are zero-initialized and must be set manually after calling the function. Example: instance = new(MyStruct) instance.field = field_value r)imp_dtorc s|j}|}||}|j||tj|||j }|j ||}| || }| t||||} || _| Sr7)r&r%r'get_abi_sizeofr#meminfo_alloc_dtor get_constantruintpmoduler$r(r)storerget_null_value make_helperrrh) rr signaturerGr-r. alloc_sizer data_pointer inst_structrrMrrcodegen0s    znew..codegen) numba.experimental.jitclass.baser instance_type) typingctxrrrLrrrrss rscs<eZdZdZdZefddZddZeddZ Z S) StructRefProxyzA PyObject proxy to the Numba allocated structref data structure. Notes ----- * Subclasses should not define ``__init__``. * Subclasses can override ``__new__``. )_typerfcst|}||_||_|S)aOCalled by boxing logic, the conversion of Numba internal representation into a PyObject. Parameters ---------- ty : a Numba type instance. mi : a wrapped MemInfoPointer. Returns ------- instance : a StructRefProxy instance. )super__new__rrf)clstyrrO __class__rrroUs zStructRefProxy._numba_box_cs@zj}W||Stytfdd}|_Y||Sw)zConstruct a new instance of the structref. This takes positional-arguments only due to limitation of the compiler. The arguments are mapped to ``cls(*args)`` in jit-code. cs|Sr7r)rGrrrrtvsz$StructRefProxy.__new__..ctor)_StructRefProxy__numba_ctorAttributeErrorr)rrGrtrrrrks zStructRefProxy.__new__cCs|jS)znReturns the Numba type instance for this structref instance. Subclasses should NOT override. )r)rrrr _numba_type_}szStructRefProxy._numba_type_) r3r4r5r6 __slots__ classmethodrorpropertyr __classcell__rrrrrJsrc CsH|\}}|j\}}t||||dj}t||||dj} |d|| S)z Define the 'is' operator for structrefs by comparing the memory addresses. This is the identity check for structref objects. rz==)rGrr icmp_unsigned) rrrLrGabatybtya_ptrb_ptrrrr structref_iss  r)$r6operatornumba.core.cgutilsrnumbar numba.corerrrnumba.core.datamodelrrnumba.core.extendingr r r r r rrrrnumba.core.typing.templatesrrrTrqrrrrsris_rmrrrrrs&  , G+9 # *<