Struct conquer_once::raw::Lazy

pub struct Lazy<T, B, F = fn() -> T> { /* fields omitted */ }

A type for lazy initialization of e.g. global static variables, which provides the same functionality as the lazy_static! macro.

Implementations

impl<T, B, F> Lazy<T, B, F>

pub const fn new(init: F) -> Self

Creates a new uninitialized Lazy with the given init closure.

Examples

The init argument can be a simple function pointer or any FnOnce closure.

use conquer_once::Lazy;

static LAZY_1: Lazy<Vec<i32>> = Lazy::new(|| vec![1, 2, 3, 4, 5]);
static LAZY_2: Lazy<Vec<i32>> = Lazy::new(Vec::<i32>::new);

impl<T, B, F> Lazy<T, B, F> where
    B: Block,
    F: FnOnce() -> T, 

pub fn is_initialized(lazy: &Self) -> bool

Returns true if the Lazy has been successfully initialized.

pub fn is_poisoned(lazy: &Self) -> bool

Returns true if the Lazy has been poisoned.

pub fn get_or_init(lazy: &Self) -> &T

Returns a reference to the already initialized inner value or initializes it first.

This has the same effect as using the Deref operator on a Lazy.

Panics

This method panics if the init procedure specified during construction panics or if the Lazy is poisoned.

Trait Implementations

impl<T, B, F> AsRef<T> for Lazy<T, B, F> where
    B: Block,
    F: FnOnce() -> T, 

fn as_ref(&self) -> &T

Performs the conversion.

impl<T, B, F> Borrow<T> for Lazy<T, B, F> where
    B: Block,
    F: FnOnce() -> T, 

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, B, F> Debug for Lazy<T, B, F> where
    T: Debug,
    B: Block,
    F: FnOnce() -> T, 

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

Formats the value using the given formatter.

impl<T, B, F> Deref for Lazy<T, B, F> where
    B: Block,
    F: FnOnce() -> T, 

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, B, F> Display for Lazy<T, B, F> where
    T: Display,
    B: Block,
    F: FnOnce() -> T, 

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

Formats the value using the given formatter.