Struct spin::lazy::Lazy

source ·
pub struct Lazy<T, F = fn() -> T, R = Spin> { /* private fields */ }
Expand description

A value which is initialized on the first access.

This type is a thread-safe Lazy, and can be used in statics.

§Examples

use std::collections::HashMap;
use spin::Lazy;

static HASHMAP: Lazy<HashMap<i32, String>> = Lazy::new(|| {
    println!("initializing");
    let mut m = HashMap::new();
    m.insert(13, "Spica".to_string());
    m.insert(74, "Hoyten".to_string());
    m
});

fn main() {
    println!("ready");
    std::thread::spawn(|| {
        println!("{:?}", HASHMAP.get(&13));
    }).join().unwrap();
    println!("{:?}", HASHMAP.get(&74));

    // Prints:
    //   ready
    //   initializing
    //   Some("Spica")
    //   Some("Hoyten")
}

Implementations§

source§

impl<T, F, R> Lazy<T, F, R>

source

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

Creates a new lazy value with the given initializing function.

source

pub fn as_mut_ptr(&self) -> *mut T

Retrieves a mutable pointer to the inner data.

This is especially useful when interfacing with low level code or FFI where the caller explicitly knows that it has exclusive access to the inner data. Note that reading from this pointer is UB until initialized or directly written to.

source§

impl<T, F: FnOnce() -> T, R: RelaxStrategy> Lazy<T, F, R>

source

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

Forces the evaluation of this lazy value and returns a reference to result. This is equivalent to the Deref impl, but is explicit.

§Examples
use spin::Lazy;

let lazy = Lazy::new(|| 92);

assert_eq!(Lazy::force(&lazy), &92);
assert_eq!(&*lazy, &92);

Trait Implementations§

source§

impl<T: Debug, F, R> Debug for Lazy<T, F, R>

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

fn default() -> Self

Creates a new lazy value using Default as the initializing function.

source§

impl<T, F: FnOnce() -> T, R: RelaxStrategy> Deref for Lazy<T, F, R>

source§

type Target = T

The resulting type after dereferencing.
source§

fn deref(&self) -> &T

Dereferences the value.
source§

impl<T, F: Send> Sync for Lazy<T, F>
where Once<T>: Sync,

Auto Trait Implementations§

§

impl<T, F = fn() -> T, R = Spin> !Freeze for Lazy<T, F, R>

§

impl<T, F = fn() -> T, R = Spin> !RefUnwindSafe for Lazy<T, F, R>

§

impl<T, F, R> Send for Lazy<T, F, R>
where T: Send, F: Send,

§

impl<T, F = fn() -> T, R = Spin> !Sync for Lazy<T, F, R>

§

impl<T, F, R> Unpin for Lazy<T, F, R>
where R: Unpin, F: Unpin, T: Unpin,

§

impl<T, F, R> UnwindSafe for Lazy<T, F, R>
where R: UnwindSafe, F: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.