Struct libil2cpp::Il2CppString

#[repr(transparent)]
pub struct Il2CppString(_);

An il2cpp string

Implementations

impl Il2CppString

pub fn new(s: impl AsRef<str>) -> &'static mut Self

Creates a new string from a Rust string

pub fn to_string(&self) -> Result<String, FromUtf16Error>

Converts the string to a Rust string, returning an error if its utf-16 data is invalid

pub fn to_string_lossy(&self) -> String

Converts the string to a Rust string, replacing any of its invalid data with the replacement character (U+FFFD)

pub fn as_utf16(&self) -> &[u16]

Returns the string’s utf-16 data as a slice

pub fn as_utf16_mut(&mut self) -> &mut [u16]

Returns the string’s utf-16 data as a mutable slice

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 AsMut<[u16]> for Il2CppString

fn as_mut(&mut self) -> &mut [u16]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u16]> for Il2CppString

fn as_ref(&self) -> &[u16]

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for Il2CppString

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

Formats the value using the given formatter.

impl Deref for Il2CppString

type Target = Il2CppObject

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Il2CppString

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

Mutably dereferences the value.

impl<'de> Deserialize<'de> for &mut Il2CppString

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

Deserialize this value from the given Serde deserializer.

impl Display for Il2CppString

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

Formats the value using the given formatter.

impl<T> From<T> for &'static mut Il2CppString where
    T: AsRef<str>, 

fn from(s: T) -> Self

Converts to this type from the input type.

impl FromStr for &'static mut Il2CppString

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T> PartialEq<T> for Il2CppString where
    T: AsRef<str>, 

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for Il2CppString

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

Serialize this value into the given Serde serializer.

impl TryFrom<&Il2CppString> for String

type Error = FromUtf16Error

The type returned in the event of a conversion error.

fn try_from(value: &Il2CppString) -> Result<Self, Self::Error>

Performs the conversion.

impl Type for Il2CppString

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

Type of the values held in variables of the type

type HeldRaw = *mut Il2CppString

Non-generic version of [Held].

const NAMESPACE: &'static str = "System"

Namespace containingthe class the type represents

const CLASS_NAME: &'static str = "String"

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 Il2CppString

type Raw = Il2CppString

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