Struct dynamic_object::Object

pub struct Object<T: Class, ContainerT = Box<dyn Dyn>> { /* private fields */ }

An object The ContainerT generic parameter controls the container of the object’s pointer Dereference it (*object) to get the inner class

Implementations

impl<T: Class, ContainerT> Object<T, ContainerT>

pub fn new(object: ContainerT) -> Self

Constructs an object from a container

Example:

#[subclass(DynamicObjectBase)]
struct MyObject;
 
let object = Object::<MyObject>::new(Box::new(MyObject {}));

pub fn isa<Other: Class>(&self) -> bool

Check if the object is a child of Other or is type Other

Example:

 #[subclass(DynamicObjectBase)]
struct MyObject;
 
let object = Object::<MyObject>::new(Box::new(MyObject {}));
assert!(object.isa::<DynamicObjectBase::>());

pub fn cast<Cast: Class>(self) -> Object<Cast, ContainerT>

Cast to type ‘Cast’ panic if ‘self’ does not inherit from ‘Cast’/ is not ‘Cast’

Example:

#[subclass(DynamicObjectBase)]
struct Class {
      value: u32,
      foo: u32
}
#[subclass(Class, parent)]
struct Derived {
      field: u32,
      parent: Class,
}
 
let object = Derived {
      parent: Class {
            value: 548389,
            foo: 72840548
      },
      field: 2153746,
};
 
let object = Object::<Derived>::new(Box::new(object));
 
assert!(object.field == 2153746);
assert!(object.parent.value == 548389);
assert!(object.parent.foo == 72840548);
 
let object = object.cast::<Class>();
assert!(object.value == 548389);
assert!(object.foo == 72840548);
 
let object = object.cast::<Derived>();
assert!(object.field == 2153746);
assert!(object.parent.value == 548389);
assert!(object.parent.foo == 72840548);

pub fn try_cast<Cast: Class>(self) -> Option<Object<Cast, ContainerT>>

Try to cast to ‘Cast’

Trait Implementations

impl<T: Class, Container: Clone> Clone for Object<T, Container>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Class, Container: Deref> Deref for Object<T, Container>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Class, Container: DerefMut> DerefMut for Object<T, Container>

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

Mutably dereferences the value.

impl<T: Class, Container: Copy> Copy for Object<T, Container>