Struct wrapped_mono::Object

pub struct Object { /* private fields */ }

Safe representation of a refernece to a manged Object. Is not nullable when passed between managed and unmanged code(e.g when added as an argument to function exposed as an interna call). It means that while it may represent a nullable type, wrapped-mono will automaticly panic when recived null value. For nullable support use Option<Object>.

Implementations

impl Object

pub fn new(domain: &Domain, class: &Class) -> Self

Allocates new object of Class class. Does not call the constructor, to call constuctor call the .ctor method after creating the object.

Examples

let new_obj = Object::new(&domain,&class);

pub unsafe fn from_ptr(obj_ptr: *mut MonoObject) -> Option<Self>

Creates new Object from pointer obj_ptr. Checks if it is null, and returns None if so.

Safety

obj_ptr must be either a valid [MonoObject] pointer or null, otherwise resulting Object will not be valid and will cause crashes.

pub fn unbox<T: InteropBox + Copy>(&self) -> T

Unboxes the value in Object self.

Safety

Calling it on a type which can’t be unboxed will lead to a crash.

Panics

Type T must match the unboxed managed type. Unboxing type C#

int num = 123;
Object boxed = num;
RustFunction(boxed);

Rust

#[invokable]
fn rust_function(o:Object){
    let val = o.unbox::<i32>();
}

pub fn box_val<T: InteropBox>(domain: &Domain, data: T) -> Self

Boxes value into an object.

Examples

 let mut val:i32 = 0;
 let obj = Object::box_val::<i32>(&domain,val); //New object of type `Int32?`

pub fn get_virtual_method<T: TupleToPtrs + CompareClasses + InteropSend>( obj: &Self, method: &Method<T> ) -> Option<Method<T>>where <T as InteropSend>::TargetType: TupleToPtrs,

Gets an implementation virtual Method method for a specific Object obj.

Explanation

with given C# code

 class ParrentClass{
     virtual void SomeMehod(){
         //SomeFunction
     }
 }
 class ChildClass : ParrentClass{
     override void SomeMehod(){
         ///SomeOtherFunction
     }
 }

When you callget_vitual_method on object that is instance of ChildClass and method ParrentClass::SomeMethod you will get return value of ChildClass::SomeMethod.

impl Object

pub fn clone_managed_object(&self) -> Self

Clones the underlying [MonoObject] not the reference to this object. (e.g when called on a reference to a managed object A will create second object B, not another reference to object A).

Trait Implementations

impl Clone for Object

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl InteropClass for Object

fn get_mono_class() -> Class

impl ObjectTrait for Object

fn get_ptr(&self) -> *mut MonoObject

Gets internal [MonoObject] pointer.

unsafe fn from_ptr_unchecked(obj_ptr: *mut MonoObject) -> Self

Creates new instance of Self from *mut [MonoObject]. Pointer is guaranteed to be not null, and of type which can be assigned to managed type represented by Self.

fn cast<Target: ObjectTrait>(&self) -> Option<Target>

unsafe fn from_ptr(obj_ptr: *mut MonoObject) -> Option<Self>

Creates new instance of Self from *mut [MonoObject]. Returns None if either obj_ptr is null OR object obj_ptr points to is of a type which does not derive from the managed type Self represents.

fn hash(&self) -> i32

get hash of this object: This hash is not based on values of objects fields, and differs from result of calling object.GetHash()

fn get_domain(&self) -> Domain

get Domain this object exists in.

fn get_size(&self) -> u32

get size of managed object referenced by self in bytes. Does include builtin hidden data.

fn get_class(&self) -> Class

Returns Class of this object. NOTE: This is function returns the class of the underlying object, not class represented by Self. This means that class returned from get_class may be a class derived from class Self represents.

fn to_mstring(&self) -> Result<Option<MString>, Exception>

Returns result of calling ToString on this Object.

impl<O: ObjectTrait> PartialEq<O> for Object

fn eq(&self, other: &O) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.