U hd,@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)selfrrrrU/home/sam/Atlas/atlas_env/lib/python3.8/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_ref3sz_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) rrrrrZ 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,r/rrrrrs   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||jkr|j|}|SdSN) field_dict)rtypattrZattrtyrrrgeneric_resolveis  z:define_attributes..StructAttribute.generic_resolveN)r0r1r2keyr8rstruct_typeclassrrStructAttributeesr<c Ss:t|||}||}t||}|j|}t||||Sr4)rr/getattrr5rZimpl_ret_borrowed) rrr6rr7utilsr.retZ fieldtyperrrstruct_getattr_implns     z.define_attributes..struct_getattr_implcSs||j\}}|\}}t|||} | |} |j|} ||||| } t| |} |j||| |j||| t | || dSr4) argsrr/r5castr=r!Zincrefdecrefsetattr)rrsigrAr7 inst_typeZval_typeinstancerr>r.Z field_typeZcasted old_valuerrrstruct_setattr_implvs     z.define_attributes..struct_setattr_implN)rrr r )r;r<r@rIrr:rdefine_attributes^s  rJcsH|tjkrtdtj|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 pyapiZ unserializeZserialize_objectZcall_function_objargsrC) r6rcr> struct_refrmip_typeZ boxed_meminfoZ ctor_pyfuncZty_pyobjresZobj_ctorrrbox_struct_refs      z%define_boxing..box_struct_refc Ss^|j|d}ttj}|||j}t|j|j |}| |}| }|j |t |S)N_meminfo)rNZobject_getattr_stringrrLrMr rrrrr _getvaluerCr ) r6objrOZmi_objrQrr>rPoutrrrunbox_struct_refs   z'define_boxing..unbox_struct_refN)r StructRef ValueError _numba_box_r r )rZ obj_classrTrYrrSr define_boxings r]c Csd|}d}g}|D]}|d|d|qd||}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)joinappendlistdictr_execr) py_classr;fieldsparamsindentZinit_fields_bufkZ init_fieldssourceZglbsr`rrrdefine_constructors*   rlcCst|||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)rlr])rfr;rgrrr define_proxys rmcCs4|tjkrtdtjt|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) rK)rrZr[rregisterrZStructRefModelrJ)rrrrrns  rncs0ddlm|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||||} || _| Sr4)r$r#r%Zget_abi_sizeofr!Zmeminfo_alloc_dtorZ get_constantrZuintpmoduler"r&r'storerZget_null_valueZ make_helperrrV) rr signaturerAr*r+Z alloc_sizerZ data_pointerZ inst_structrorFrrcodegen-s    znew..codegen)Z numba.experimental.jitclass.baseroZ instance_type)Z typingctxrrtrErrsrr_s r_cs<eZdZdZdZefddZddZeddZ Z S) StructRefProxyzA PyObject proxy to the Numba allocated structref data structure. Notes ----- * Subclasses should not define ``__init__``. * Subclasses can override ``__new__``. )_typerUcst|}||_||_|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__rvrU)clstyrrG __class__rrr\Rs zStructRefProxy._numba_box_cs>z j}Wn*tk r4tfdd}|_YnX||S)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|Sr4r)rAryrrr`ssz$StructRefProxy.__new__..ctor)Z_StructRefProxy__numba_ctorAttributeErrorr)ryrAr`rr}rrxhs  zStructRefProxy.__new__cCs|jS)znReturns the Numba type instance for this structref instance. Subclasses should NOT override. )rv)rrrr _numba_type_zszStructRefProxy._numba_type_) r0r1r2r3 __slots__ classmethodr\rxpropertyr __classcell__rrr{rruGsruN)r3ZnumbarZ numba.corerrrZnumba.core.datamodelrrZnumba.core.extendingrr r r r r rrZnumba.core.typing.templatesrrrJr]rlrmrnr_rurrrrs ( G+9 # *