pub struct MyDepType { /* private fields */ }Implementations
sourceimpl MyDepType
 
impl MyDepType
pub const PROP_1: DepProp<Self, bool> = {
        unsafe {
                let offset =
                    {
                            let uninit =
                                ::memoffset::__priv::mem::MaybeUninit::uninit();
                            let base_ptr: *const MyDepTypeCore = uninit.as_ptr();
                            let field_ptr =
                                {
                                        let MyDepTypeCore { prop_1: _, .. };
                                        let base = base_ptr;
                                        unsafe {
                                                { &raw const (*(base as *const MyDepTypeCore)).prop_1 }
                                            }
                                    };
                            {
                                    let field = field_ptr;
                                    let base = base_ptr;
                                    unsafe {
                                            (field as *const u8).offset_from(base as *const u8) as usize
                                        }
                                }
                        };
                crate::DepProp::new(offset)
            }
    } 
pub const PROP_2: DepProp<Self, i32> = {
        unsafe {
                let offset =
                    {
                            let uninit =
                                ::memoffset::__priv::mem::MaybeUninit::uninit();
                            let base_ptr: *const MyDepTypeCore = uninit.as_ptr();
                            let field_ptr =
                                {
                                        let MyDepTypeCore { prop_2: _, .. };
                                        let base = base_ptr;
                                        unsafe {
                                                { &raw const (*(base as *const MyDepTypeCore)).prop_2 }
                                            }
                                    };
                            {
                                    let field = field_ptr;
                                    let base = base_ptr;
                                    unsafe {
                                            (field as *const u8).offset_from(base as *const u8) as usize
                                        }
                                }
                        };
                crate::DepProp::new(offset)
            }
    } 
Trait Implementations
sourceimpl DepObj<MyDepType, MyDepType> for MyDepTypeId
 
impl DepObj<MyDepType, MyDepType> for MyDepTypeId
const STATE_PART: std_any_TypeId = crate::std_any_TypeId::of::() 
fn get_raw<'state_part_lifetime>(
    state_part: &'state_part_lifetime dyn std_any_Any, 
    this: components_arena_RawId
) -> &'state_part_lifetime MyDepType
fn get_raw_mut<'state_part_lifetime>(
    state_part: &'state_part_lifetime mut dyn std_any_Any, 
    this: components_arena_RawId
) -> &'state_part_lifetime mut MyDepType
fn get(state: &dyn State, id: RawId) -> DepObjRef<'_, Type>
fn get_mut(state: &mut dyn State, id: RawId) -> DepObjMut<'_, Type>
Auto Trait Implementations
impl !RefUnwindSafe for MyDepType
impl !Send for MyDepType
impl !Sync for MyDepType
impl Unpin for MyDepType
impl !UnwindSafe for MyDepType
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
    T: ?Sized, 
 
impl<T> BorrowMut<T> for T where
    T: ?Sized, 
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Downcast for T where
    T: Any, 
 
impl<T> Downcast for T where
    T: Any, 
sourcefn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
 
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more
sourcefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
 
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more
sourcefn as_any(&self) -> &(dyn Any + 'static)
 
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s. Read more
sourcefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
 
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s. Read more