o Td,@sdZddlmZddlmZmZmZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZddlmZGdddZd d Zd d Zd dZddZddZeddZGdddZdS)zUtilities for defining a mutable struct. A mutable struct is passed by reference; hence, structref (a reference to a struct). )njit)typesimputilscgutils)default_managermodels) infer_getattrlower_getattr_genericlower_setattr_genericboxunbox 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)selfrrrro/home/ncw/WWW/www-new/content/articles/pi-bbp/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` )rrrrcreate_struct_proxymeminfo)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_ref3s 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) rrrrr structvalrdata_ptrvaltypemodel alloc_typerrrget_data_pointer>s  z_Utils.get_data_pointercCs<|j}|j}|j}||}|}t||||d}|S)zFGet a getter/setter helper for accessing a `StructRefPayload` )ref)rrrr-r#rr)rrrrrr)r*datavalrrrget_data_structOs z_Utils.get_data_structN) __name__ __module__ __qualname____doc__rrr r-r0rrrrrs  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_resolveis  z:define_attributes..StructAttribute.generic_resolveN)r1r2r3keyr:rstruct_typeclassrrStructAttributees r>c Ss:t|||}||}t||}|j|}t||||Sr5)rr0getattrr6rimpl_ret_borrowed) rrr7rr8utilsr/ret fieldtyperrrstruct_getattr_implns    z.define_attributes..struct_getattr_implcSs||j\}}|\}}t|||} | |} |j|} ||||| } t| |} |j||| |j||| t | || dSr5) argsrr0r6castr?r!increfdecrefsetattr)rrsigrEr8 inst_typeval_typeinstancerrAr/ field_typecasted old_valuerrrstruct_setattr_implvs     z.define_attributes..struct_setattr_implN)rrr r )r=r>rDrQrr<rdefine_attributes^s  rRcsH|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_objargsrH) r7rcrA 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)rVobject_getattr_stringrrTrUr rrrrr _getvaluerHr ) r7objrZmi_objr\rrAr[outrrrunbox_struct_refs   z'define_boxing..unbox_struct_refN)r StructRef ValueError _numba_box_r r )r obj_classrcrjrrar define_boxings roc 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)joinappendlistdictrqexecr) py_classr=fieldsparamsindentinit_fields_bufk init_fieldssourceglbsrrrrrdefine_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)rro)rxr=ryrrr 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) rS)rrkrlrregisterrStructRefModelrR)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||||} || _| Sr5)r$r#r%get_abi_sizeofr!meminfo_alloc_dtor get_constantruintpmoduler"r&r'storerget_null_value make_helperrrf) rr signaturerEr+r, alloc_sizer data_pointer inst_structrrKrrcodegen-s    znew..codegen) numba.experimental.jitclass.baser instance_type) typingctxrrrJrrrrqs rqcs<eZdZdZdZefddZddZeddZ Z S) StructRefProxyzA PyObject proxy to the Numba allocated structref data structure. Notes ----- * Subclasses should not define ``__init__``. * Subclasses can override ``__new__``. )_typerdcst|}||_||_|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__rrd)clstyrrM __class__rrrmRs 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|Sr5r)rErrrrrssz$StructRefProxy.__new__..ctor)_StructRefProxy__numba_ctorAttributeErrorr)rrErrrrrrhs zStructRefProxy.__new__cCs|jS)znReturns the Numba type instance for this structref instance. Subclasses should NOT override. )r)rrrr _numba_type_zszStructRefProxy._numba_type_) r1r2r3r4 __slots__ classmethodrmrpropertyr __classcell__rrrrrGsrN)r4numbar numba.corerrrnumba.core.datamodelrrnumba.core.extendingrr r r r r rrnumba.core.typing.templatesrrrRrorrrrqrrrrrs ( G+9 # *