Struct MetaTable

pub struct MetaTable<T>
where
    T: ?Sized,
{ /* private fields */ }

The MetaTable which allows to store object-safe trait implementations for resources.

For example, you have a trait Foo that is implemented by several resources. You can register all the implementors using MetaTable::register. Later on, you can iterate over all resources that implement Foo without knowing their specific type.

Examples

use shred::{CastFrom, MetaTable, Resources};

trait Object {
    fn method1(&self) -> i32;

    fn method2(&mut self, x: i32);
}

impl<T> CastFrom<T> for Object
where
    T: Object + 'static,
{
    fn cast(t: &T) -> &Self {
        t
    }

    fn cast_mut(t: &mut T) -> &mut Self {
        t
    }
}

struct ImplementorA(i32);

impl Object for ImplementorA {
    fn method1(&self) -> i32 {
        self.0
    }

    fn method2(&mut self, x: i32) {
        self.0 += x;
    }
}

struct ImplementorB(i32);

impl Object for ImplementorB {
    fn method1(&self) -> i32 {
        self.0
    }

    fn method2(&mut self, x: i32) {
        self.0 *= x;
    }
}

let mut res = Resources::new();

res.insert(ImplementorA(3));
res.insert(ImplementorB(1));

let mut table = MetaTable::<Object>::new();
table.register(&ImplementorA(31415)); // Can just be some instance of type `&ImplementorA`.
table.register(&ImplementorB(27182));

{
    let mut iter = table.iter(&mut res);
    assert_eq!(iter.next().unwrap().method1(), 3);
    assert_eq!(iter.next().unwrap().method1(), 1);
}

Implementations

impl<T> MetaTable<T>

where T: ?Sized,

pub fn new() -> MetaTable<T>

Creates a new MetaTable.

pub fn register<R>(&mut self, r: &R)

where R: Resource, T: CastFrom<R> + 'static,

Registers a resource R that implements the trait T. This just needs some instance of type R to retrieve the vtable. It doesn’t have to be the same object you’re calling get with later.

pub fn get<'a>(&self, res: &'a (dyn Resource + 'static)) -> Option<&'a T>

Tries to convert res to a trait object of type &T. If res doesn’t have an implementation for T (or it wasn’t registered), this will return None.

pub fn get_mut<'a>( &self, res: &'a (dyn Resource + 'static), ) -> Option<&'a mut T>

Tries to convert res to a trait object of type &mut T. If res doesn’t have an implementation for T (or it wasn’t registered), this will return None.

pub fn iter<'a>(&'a self, res: &'a Resources) -> MetaIter<'a, T>

Iterates all resources that implement T and were registered.

pub fn iter_mut<'a>(&'a self, res: &'a Resources) -> MetaIterMut<'a, T>

Iterates all resources that implement T and were registered mutably.

Trait Implementations

impl<T> Default for MetaTable<T>

where T: ?Sized,

fn default() -> MetaTable<T>

Returns the “default value” for a type.