Struct StaticInstances 

pub struct StaticInstances<T>
where
    T: Object,
{ /* private fields */ }

This is the real type of variables wrapped in the linked::instances! macro. See macro documentation for more details.

Instances of this type are created by the linked::instances! macro, never directly by user code, which can use .get() to obtain a linked instance of T.

Implementations

impl<T> StaticInstances<T>

where T: Object,

pub fn get(&self) -> T

Creates a new linked instance of T from the same family of linked objects as other instances created via the same static variable.

Example

use std::thread;

linked::instances!(static COUNTER: Counter = Counter::new());

// Each call to get() creates a new linked instance
let mut counter1 = COUNTER.get();
let mut counter2 = COUNTER.get();

counter1.increment();
counter2.increment();

// Local counts are independent per instance
assert_eq!(counter1.local_count(), 1);
assert_eq!(counter2.local_count(), 1);

// But global state is shared across the family
assert_eq!(counter1.global_count(), 2);
assert_eq!(counter2.global_count(), 2);

// Works across threads too
thread::spawn(|| {
    let mut counter3 = COUNTER.get();
    counter3.increment();
    assert_eq!(counter3.global_count(), 3);
}).join().unwrap();

Performance

This creates a new instance of T on every call so caching the return value is performance-critical.

If you only need one instance per thread, consider using the linked::thread_local_rc! or linked::thread_local_arc! macro for a more efficient solution.

Trait Implementations

impl<T> Debug for StaticInstances<T>

where T: Object + Debug,

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

Formats the value using the given formatter.