Trait dep_obj::DepType[−][src]

pub trait DepType: Sized {
    type Id: ComponentId;
}
Expand description

A dependency type. Use the dep_type or the dep_type_with_builder macro to create a type implementing this trait.

Examples

use components_arena::{Arena, Component, ComponentClassToken, ComponentId, Id};
use dep_obj::{Dispatcher, dep_obj, dep_type};
use dyn_context::State;
use macro_attr_2018::macro_attr;
use std::any::{Any, TypeId};

dep_type! {
    #[derive(Debug)]
    pub struct MyDepType in MyDepTypeId {
        prop_1: bool = false,
        prop_2: i32 = 10,
    }
}

macro_attr! {
    #[derive(Component!, Debug)]
    struct MyDepTypePrivateData {
        dep_data: MyDepType,
    }
}

macro_attr! {
    #[derive(ComponentId!, Debug, Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
    pub struct MyDepTypeId(Id<MyDepTypePrivateData>);
}

pub struct MyApp {
    dispatcher: Dispatcher,
    my_dep_types: Arena<MyDepTypePrivateData>,
}

impl State for MyApp {
    fn get_raw(&self, ty: TypeId) -> Option<&dyn Any> {
        if ty == TypeId::of::<Dispatcher>() {
            Some(&self.dispatcher)
        } else if ty == TypeId::of::<MyApp>() {
            Some(self)
        } else {
            None
        }
    }

    fn get_mut_raw(&mut self, ty: TypeId) -> Option<&mut dyn Any> {
        if ty == TypeId::of::<Dispatcher>() {
            Some(&mut self.dispatcher)
        } else if ty == TypeId::of::<MyApp>() {
            Some(self)
        } else {
            None
        }
    }
}

impl MyDepTypeId {
    pub fn new(app: &mut MyApp) -> MyDepTypeId {
        app.my_dep_types.insert(|id| (MyDepTypePrivateData {
            dep_data: MyDepType::new_priv()
        }, MyDepTypeId(id)))
    }

    dep_obj! {
        pub fn obj(self as this, app: MyApp) -> MyDepType {
            if mut {
                &mut app.my_dep_types[this.0].dep_data
            } else {
                &app.my_dep_types[this.0].dep_data
            }
        }
    }
}

fn main() {
    let mut my_dep_types_token = ComponentClassToken::new().unwrap();
    let mut app = MyApp {
        dispatcher: Dispatcher::new(),
        my_dep_types: Arena::new(&mut my_dep_types_token),
    };
    let id = MyDepTypeId::new(&mut app);
    assert_eq!(id.obj_ref(&app).get(MyDepType::PROP_2), &10);
    id.obj_mut(&mut app).set_distinct(MyDepType::PROP_2, 5);
    assert_eq!(id.obj_ref(&app).get(MyDepType::PROP_2), &5);
}

Associated Types

Implementors