Struct Family

pub struct Family<T> { /* private fields */ }

Represents a family of linked objects and allows you to create additional instances in the same family.

Clones represent the same family and are functionally equivalent.

When to use this type

The family is a low-level primitive for creating instances of linked objects. You will need to use it directly if you are implementing custom instance management patterns. Typical usage of linked objects occurs via standard macros/wrappers provided by the crate:

• linked::instances!
• linked::thread_local_rc!
• linked::thread_local_arc! (if T: Sync)
• linked::InstancePerThread<T>
• linked::InstancePerThreadSync<T> (if T: Sync)

Example

use std::thread;

use linked::Object; // This brings .family() into scope.

let thing = Thing::new("hello".to_string());
assert_eq!(thing.value(), "hello");

thing.set_value("world".to_string());

thread::spawn({
    let thing_family = thing.family();

    move || {
        let thing: Thing = thing_family.into();
        assert_eq!(thing.value(), "world");
    }
})
.join()
.unwrap();

Trait Implementations

impl<T: Clone> Clone for Family<T>

fn clone(&self) -> Family<T>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Family<T>

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

Formats the value using the given formatter.

impl<T: ?Sized + 'static> From<Family<Box<T>>> for Box<T>

fn from(family: Family<Box<T>>) -> Self

Converts to this type from the input type.