Struct static_init::UnSyncLazy

pub struct UnSyncLazy<T, G = fn() -> T> { /* fields omitted */ }

A version of Lazy whose reference can not be passed to other thread

Implementations

impl<T, G> UnSyncLazy<T, G>

pub const fn from_generator(f: G) -> Self

Build a new static object

Safety

This function may be unsafe if building any thing else than a thread local object or a static will be the cause of undefined behavior

pub const fn from_generator_with_info(f: G, info: StaticInfo) -> Self

Build a new static object with debug information

Safety

This function may be unsafe if building any thing else than a thread local object or a static will be the cause of undefined behavior

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

pub fn get(this: &Self) -> &T

Initialize if necessary then return a reference to the target.

Panics

Panic if previous attempt to initialize has panicked and the lazy policy does not tolorate further initialization attempt or if initialization panic.

pub fn try_get(this: &Self) -> Result<&T, AccessError>

Return a reference to the target if initialized otherwise return an error.

pub fn get_mut(this: &mut Self) -> &mut T

Initialize and return a mutable reference to the target

This method is extremly efficient as it does not requires any form of locking when initializing

pub fn try_get_mut(this: &mut Self) -> Result<&mut T, AccessError>

Return a mutable reference to the target if initialized otherwise return an error.

This method is extremly efficient as it does not requires any form of locking when initializing

pub fn phase(this: &Self) -> Phase

Return the phase

pub fn init(this: &Self) -> Phase

Initialize the lazy if not yet initialized

Panic

Panic if the generator panics

impl<T, G> UnSyncLazy<T, Cell<Option<G>>> where
    G: FnOnce() -> T, 

pub fn new(g: G) -> Self

Trait Implementations

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for UnSyncLazy<T, fn() -> T>

fn default() -> Self

Returns the “default value” for a type.

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, G> Drop for UnSyncLazy<T, G>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, G> LazyAccess for &'a UnSyncLazy<T, G> where
    G: Generator<T>, 

type Target = &'a T

fn get(this: Self) -> &'a T

Initialize if necessary then return a reference to the target.

fn try_get(this: Self) -> Result<&'a T, AccessError>

Return a reference to the target if initialized otherwise return an error.

fn phase(this: Self) -> Phase

The current phase of the static

fn init(this: Self) -> Phase

Initialize the static if there were no previous attempt to initialize it.

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

fn phase(this: &Self) -> Phase

return the current phase