Struct shred::MetaTable

pub struct MetaTable<T: ?Sized> { /* fields omitted */ }

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, World};

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

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

unsafe impl<T> CastFrom<T> for dyn 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 world = World::empty();

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

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

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

Methods

impl<T: ?Sized> MetaTable<T>

pub fn new() -> Self

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) -> Option<&'a T>

Tries to convert world to a trait object of type &T. If world 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) -> Option<&'a mut T>

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

Important traits for MetaIter<'a, T>

impl<'a, T: ?Sized> Iterator for MetaIter<'a, T> where
    T: 'a,  type Item = &'a T;

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

Iterates all resources that implement T and were registered.

Important traits for MetaIterMut<'a, T>

impl<'a, T: ?Sized> Iterator for MetaIterMut<'a, T> where
    T: 'a,  type Item = &'a mut T;

pub fn iter_mut<'a>(&'a self, res: &'a World) -> 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() -> Self

Returns the "default value" for a type.