Struct libil2cpp::Il2CppArray

#[repr(transparent)]
pub struct Il2CppArray<T: Type>(_, _);

An il2cpp array

Implementations

impl<T: Type> Il2CppArray<T>

pub fn new<'a, I>(items: I) -> &'a mut Self where
    I: IntoIterator<Item = T::Held<'a>>,
    I::IntoIter: ExactSizeIterator<Item = T::Held<'a>>, 

Creates an array from an iterator

pub fn as_slice(&self) -> &[T::Held<'_>]

Slice of values in the array

pub fn as_mut_slice(&mut self) -> &mut [T::Held<'_>]

Mutable slice of values in the array

pub fn len(&self) -> usize

Length of the array

pub fn is_empty(&self) -> bool

Whether the array is empty

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<T: Type> Debug for Il2CppArray<T> where
    for<'a> T::Held<'a>: Debug, 

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

Formats the value using the given formatter.

impl<T: Type> Deref for Il2CppArray<T>

type Target = Il2CppObject

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Type> DerefMut for Il2CppArray<T>

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

Mutably dereferences the value.

impl<'de, T: Type> Deserialize<'de> for &'de mut Il2CppArray<T> where
    T::Held<'de>: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Type> Serialize for Il2CppArray<T> where
    for<'a> T::Held<'a>: Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: Type> Type for Il2CppArray<T>

type Held<'a> = Option<&'a mut Il2CppArray<T>>

Type of the values held in variables of the type

type HeldRaw = *mut Il2CppArray<T>

Non-generic version of [Held].

const NAMESPACE: &'static str = "System"

Namespace containingthe class the type represents

const CLASS_NAME: &'static str = "Array"

Name of the class the type represents

fn class() -> &'static Il2CppClass

Il2CppClass of the type

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 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<T: Type> WrapRaw for Il2CppArray<T>

type Raw = Il2CppArray

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