Struct libil2cpp::Il2CppReflectionType

pub struct Il2CppReflectionType(_);

Object used for reflection of types

Implementations

impl Il2CppReflectionType

pub fn ty(&self) -> &Il2CppType

Il2CppType which this object represents

pub fn make_generic<G>(&self) -> Result<Option<&Self>, &mut Il2CppException> where
    G: Generics, 

Instanciates a generic type template with the provided generic arguments

Methods from Deref<Target = Il2CppObject>

pub fn class(&self) -> &'static Il2CppClass

Il2CppClass of the object

pub fn invoke<A, R, const N: usize>(
    &mut self,
    name: &str,
    args: A
) -> Result<R, &mut Il2CppException> where
    A: Arguments<N>,
    R: Returned, 

Invokes the method with the given name on self using the given arguments, with type checking

Panics

This method will panic if a matching method can’t be found.

pub fn invoke_void<A, const N: usize>(
    &mut self,
    name: &str,
    args: A
) -> Result<(), &mut Il2CppException> where
    A: Arguments<N>, 

Invokes the void method with the given name on self using the given arguments, with type checking

Panics

This method will panic if a matching method can’t be found.

pub fn load<T>(&mut self, field: &str) -> T::Held<'_> where
    T: Type, 

Loads a value from a field of self with the given name, with type checking

Panics

This method will panic if the given field can’t be found

pub fn store<A>(&mut self, field: &str, value: A) where
    A: Argument, 

Stores a given value into a field of self with the given name, with type checking

Panics

This method will panic if the given field can’t be found

Trait Implementations

impl Debug for Il2CppReflectionType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Il2CppReflectionType

type Target = Il2CppObject

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Il2CppReflectionType

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Type for Il2CppReflectionType

type Held<'a> = Option<&'a mut Il2CppReflectionType>

Type of the values held in variables of the type

type HeldRaw = *mut Il2CppReflectionType

Non-generic version of [Held].

const NAMESPACE: &'static str = "System"

Namespace containingthe class the type represents

const CLASS_NAME: &'static str = "RuntimeType"

Name of the class the type represents

fn matches_reference_argument(ty: &Il2CppType) -> bool

Whether a reference to the type can be used as an argument of the given Il2CppType

fn matches_value_argument(_: &Il2CppType) -> bool

Whether a value of the type can be used as an argument of the given Il2CppType

fn matches_reference_parameter(ty: &Il2CppType) -> bool

Whether a reference to the type can be used as a parameter of the given Il2CppType

fn matches_value_parameter(_: &Il2CppType) -> bool

Whether a value of the type can be used as a parameter of the given Il2CppType

fn class() -> &'static Il2CppClass

Il2CppClass of the type

fn matches_this_argument(method: &MethodInfo) -> bool

Whether the type can be used as a this argument for the given MethodInfo

fn matches_this_parameter(method: &MethodInfo) -> bool

Whether the type can be used as a this parameter for the given MethodInfo

fn matches_returned(ty: &Il2CppType) -> bool

Whether the type can be used as the value of the given Il2CppType returned from a C# method

fn matches_return(ty: &Il2CppType) -> bool

Whether the type can be used as the return value of the given Il2CppType for a C# method

impl WrapRaw for Il2CppReflectionType

type Raw = Il2CppReflectionType

Raw il2cpp type

fn raw(&self) -> &Self::Raw

Returns a reference to the underlying raw il2cpp type

unsafe fn raw_mut(&mut self) -> &mut Self::Raw

Returns a mutable reference to the underlying raw il2cpp type

unsafe fn wrap(raw: &Self::Raw) -> &Self

Wraps a reference to the raw il2cpp type

unsafe fn wrap_mut(raw: &mut Self::Raw) -> &mut Self

Wraps a mutable reference to the raw il2cpp type

unsafe fn wrap_ptr<'a>(ptr: *const Self::Raw) -> Option<&'a Self>

Wraps a const pointer to the raw il2cpp type

unsafe fn wrap_ptr_mut<'a>(ptr: *mut Self::Raw) -> Option<&'a mut Self>

Wraps a mut pointer to the raw il2cpp type