U |e,@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)selfrrrrY/var/www/website-v5/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)rtypattrattrtyrrrgeneric_resolveis  z:define_attributes..StructAttribute.generic_resolveN)r0r1r2keyr9rstruct_typeclassrrStructAttributeesr=c Ss:t|||}||}t||}|j|}t||||Sr4)rr/getattrr5rimpl_ret_borrowed) rrr6rr7utilsr.retZ fieldtyperrrstruct_getattr_implns     z.define_attributes..struct_getattr_implcSs||j\}}|\}}t|||} | |} |j|} ||||| } t| |} |j||| |j||| t | || dSr4) argsrr/r5castr>r!increfdecrefsetattr)rrsigrCr7 inst_typeval_typeinstancerr@r. field_typecasted old_valuerrrstruct_setattr_implvs     z.define_attributes..struct_setattr_implN)rrr r )r<r=rBrOrr;rdefine_attributes^s  rPcsH|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 pyapi unserializeserialize_objectcall_function_objargsrF) r6rcr@ struct_refrmip_type 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)rTobject_getattr_stringrrRrSr rrrrr _getvaluerFr ) r6objrXZmi_objrZrr@rYoutrrrunbox_struct_refs   z'define_boxing..unbox_struct_refN)r StructRef ValueError _numba_box_r r )rZ obj_classr^rdrr]r define_boxings rhc 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)joinappendlistdictrjexecr) py_classr<fieldsparamsindentZinit_fields_bufkZ init_fieldssourceglbsrkrrrdefine_constructors*   rxcCst|||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)rxrh)rqr<rrrrr define_proxys rycCs4|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) rQ)rrerfrregisterrStructRefModelrP)rrrrrzs  rzcs0ddlm|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%get_abi_sizeofr!meminfo_alloc_dtor get_constantruintpmoduler"r&r'storerget_null_value make_helperrra) rr signaturerCr*r+ alloc_sizer data_pointer inst_structr|rIrrcodegen-s    znew..codegen) numba.experimental.jitclass.baser| instance_type) typingctxrrrHrrrrjs rjcs<eZdZdZdZefddZddZeddZ Z S) StructRefProxyzA PyObject proxy to the Numba allocated structref data structure. Notes ----- * Subclasses should not define ``__init__``. * Subclasses can override ``__new__``. )_typer_cst|}||_||_|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__rr_)clstyrrK __class__rrrgRs 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)rCrrrrkssz$StructRefProxy.__new__..ctor)Z_StructRefProxy__numba_ctorAttributeErrorr)rrCrkrrrrhs  zStructRefProxy.__new__cCs|jS)znReturns the Numba type instance for this structref instance. Subclasses should NOT override. )r)rrrr _numba_type_zszStructRefProxy._numba_type_) r0r1r2r3 __slots__ classmethodrgrpropertyr __classcell__rrrrrGsrN)r3numbar numba.corerrrnumba.core.datamodelrrnumba.core.extendingrr r r r r rrnumba.core.typing.templatesrrrPrhrxryrzrjrrrrrs ( G+9 # *