Trait static_init::Phased

pub trait Phased {
    fn phase(this: &Self) -> Phase;
}

Trait for objects that know in which phase they are.

Required Methods

fn phase(this: &Self) -> Phase

return the current phase

Implementors

impl<'a, T> Phased for static_init::lazy::global_primed_locked_lazy_droped::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::global_primed_locked_lazy_droped::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy_droped::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy_droped::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy_finalize::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::lesser_locked_lazy_finalize::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::locked_lazy::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::locked_lazy::WriteGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::locked_lazy_droped::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::locked_lazy_droped::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::locked_lazy_finalize::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::locked_lazy_finalize::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_lesser_locked_lazy::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_lesser_locked_lazy::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_locked_lazy::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_locked_lazy::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_locked_lazy_droped::ReadGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::primed_locked_lazy_droped::WriteGuard<'a, T> where
    T: 'static, 

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy::WriteGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy_droped::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy_droped::WriteGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy_finalize::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_locked_lazy_finalize::WriteGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_primed_locked_lazy::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_primed_locked_lazy::WriteGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_primed_locked_lazy_droped::ReadGuard<'a, T>

impl<'a, T> Phased for static_init::lazy::unsync_primed_locked_lazy_droped::WriteGuard<'a, T>

impl<T, G> Phased for LazyFinalize<T, G> where
    G: 'static + Generator<T>,
    G: Sync,
    T: Sync,
    T: Finaly, 

impl<T, G> Phased for LesserLazy<T, G> where
    G: 'static + Generator<T>, 

impl<T, G> Phased for LesserLazyFinalize<T, G> where
    G: 'static + Generator<T>,
    G: Sync,
    T: Sync,
    T: Finaly, 

impl<T, G> Phased for LesserLockedLazy<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for LesserLockedLazyDroped<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for LesserLockedLazyFinalize<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for LockedLazyDroped<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for LockedLazyFinalize<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for PrimedLesserLockedLazy<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for PrimedLesserLockedLazyDroped<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for PrimedLockedLazy<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for PrimedLockedLazyDroped<T, G> where
    T: 'static,
    G: 'static + Generator<T>, 

impl<T, G> Phased for UnSyncLazyDroped<T, G> where
    G: 'static + Generator<T>, 

impl<T, G> Phased for UnSyncLazyFinalize<T, G> where
    G: 'static + Generator<T>,
    T: Finaly, 

impl<T, G> Phased for UnSyncLockedLazyDroped<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for UnSyncLockedLazyFinalize<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for UnSyncPrimedLockedLazy<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for UnSyncPrimedLockedLazyDroped<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for Lazy<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for LockedLazy<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for UnSyncLazy<T, G> where
    G: Generator<T>, 

impl<T, G> Phased for UnSyncLockedLazy<T, G> where
    G: Generator<T>,