def argumenttype_ivalue_convert( t: Type, arg_name: str, *, mutable: bool = False) -> Tuple[str, CType, List[str], List[str]]: ctype = cpp.argumenttype_type(t=t, mutable=mutable, binds=arg_name).type if isinstance(t, BaseType): out_name = f"{arg_name}_base" code, decl = _gen_code_base_type(arg_name=arg_name, out_name=out_name, ctype=ctype) elif isinstance(t, OptionalType): out_name = f"{arg_name}_opt_out" code, decl = _gen_code_optional_type(arg_name=arg_name, out_name=out_name, t=t, ctype=ctype) elif isinstance(t, ListType): out_name = f"{arg_name}_list_out" code, decl = _gen_code_list_type(arg_name=arg_name, out_name=out_name, t=t, ctype=ctype) else: raise Exception(f"Cannot handle type {t}. arg_name: {arg_name}") return out_name, ctype, code, decl
def dynamic_type(t: Type) -> str: if isinstance(t, OptionalType): return dynamic_type(t.elem) # Note we don't use t.is_tensor_like() here because it would # also include Tensor[] if str(t) == 'Tensor': return 'Tensor' return cpp.argumenttype_type(t, mutable=False)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> CType: if str(t) == 'Tensor?': if mutable: return MutRefCType(BaseCType('Tensor', binds)) else: return ConstRefCType(BaseCType('Tensor', binds)) elif str(t) == 'Tensor?[]': return BaseCType('const c10::List<c10::optional<Tensor>> &', binds) return cpp.argumenttype_type(t, mutable=mutable, binds=binds)
def argumenttype_type(t: Type, *, mutable: bool) -> str: if str(t) == 'Tensor?': if mutable: return 'Tensor &' else: return 'const Tensor &' elif str(t) == 'Tensor?[]': return 'TensorList' return cpp.argumenttype_type(t, mutable=mutable)
def argumenttype_type(t: Type, *, mutable: bool) -> str: if local.use_c10_dispatcher() is UseC10Dispatcher.full: # This is a faux amis. If it makes sense in the future to add # more special cases here, or invert things so cpp.argument_type # calls this, or just completely inline the function, please do # it. return cpp.argumenttype_type(t, mutable=mutable) else: # This is real sharing. If you're modifying this path, ask # yourself why you are changing the legacy dispatcher protocol # here and not in legacy_dispatcher. return legacy_dispatcher.argumenttype_type(t, mutable=mutable)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> CType: if local.use_c10_dispatcher().dispatcher_uses_new_style(): # This is a faux amis. If it makes sense in the future to add # more special cases here, or invert things so cpp.argument_type # calls this, or just completely inline the function, please do # it. return cpp.argumenttype_type(t, mutable=mutable, binds=binds) else: # This is real sharing. If you're modifying this path, ask # yourself why you are changing the native functions protocol # here and not in native. return native.argumenttype_type(t, mutable=mutable, binds=binds)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> CType: if str(t) == 'Tensor?': tensor_type: OptionalCType = OptionalCType(BaseCType('Tensor', binds)) if mutable: return MutRefCType(tensor_type) else: return ConstRefCType(tensor_type) elif str(t) == 'Tensor?[]': return ConstRefCType(BaseCType("c10::List<c10::optional<Tensor>>", binds)) elif str(t) == 'Scalar': return ConstRefCType(BaseCType('Scalar', binds)) elif str(t) == 'Scalar?': return ConstRefCType(OptionalCType(BaseCType('Scalar', binds))) return cpp.argumenttype_type(t, mutable=mutable, binds=binds)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> CType: if str(t) == 'Tensor?': tensor_type: CType = BaseCType('Tensor', binds) if local.use_c10_dispatcher( ) is not UseC10Dispatcher.hacky_wrapper_for_legacy_signatures: tensor_type = OptionalCType(tensor_type) if mutable: return MutRefCType(tensor_type) else: return ConstRefCType(tensor_type) elif str(t) == 'Tensor?[]': return ConstRefCType( BaseCType("c10::List<c10::optional<Tensor>>", binds)) return cpp.argumenttype_type(t, mutable=mutable, binds=binds)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> NamedCType: if str(t) == 'Tensor?': tensor_type: OptionalCType = OptionalCType(BaseCType(tensorT)) if mutable and not local.use_const_ref_for_mutable_tensors(): return NamedCType(binds, MutRefCType(tensor_type)) else: return NamedCType(binds, ConstRefCType(tensor_type)) elif str(t) == 'Tensor?[]': return NamedCType( binds, ConstRefCType(ListCType(OptionalCType(BaseCType(tensorT))))) elif str(t) == 'Scalar': return NamedCType(binds, ConstRefCType(BaseCType(scalarT))) elif str(t) == 'Scalar?': return NamedCType(binds, ConstRefCType(OptionalCType(BaseCType(scalarT)))) return cpp.argumenttype_type(t, mutable=mutable, binds=binds)
def argumenttype_type(t: Type, *, mutable: bool, binds: ArgName) -> CType: # This is a faux amis. If it makes sense in the future to add # more special cases here, or invert things so cpp.argument_type # calls this, or just completely inline the function, please do # it. return cpp.argumenttype_type(t, mutable=mutable, binds=binds)