Struct census::Inventory

pub struct Inventory<T> { /* fields omitted */ }

The Inventory register and keeps track of all of the objects alive.

Methods

impl<T> Inventory<T>

pub fn new() -> Inventory<T>

Creates a new inventory object

pub fn list(&self) -> Vec<TrackedObject<T>>

Takes a snapshot of the list of tracked object.

Note that the list is a simple Vec of tracked object. As a result, it is a consistent snapshot of the list of living instance at the time of the call,

Obviously, instances may have been created after the call. They will obviously not appear in the snapshot.

let inventory = Inventory::new();

let one = inventory.track("one".to_string());
let living_instances: Vec<TrackedObject<String>> = inventory.list();
let two = inventory.track("two".to_string());

// our snapshot is a bit old.
assert_eq!(living_instances.len(), 1);

// a fresher snapshot would contain our new element.
assert_eq!(inventory.list().len(), 2);

Also, the instance in the snapshot itself are considered "living".

As a result, as long as a snapshot is not dropped, all of its instances will be part of the inventory.

let inventory = Inventory::new();

let one = inventory.track("one".to_string());
let living_instances: Vec<TrackedObject<String>> = inventory.list();

// let's drop one here
drop(one);

// The instance is technically still in the inventory
// as our previous snapshot is extending its life...
assert_eq!(inventory.list().len(), 1);

// If we drop our previous snapshot however...
drop(living_instances);

// `one` is really untracked.
assert!(inventory.list().is_empty());

pub fn track(&self, t: T) -> TrackedObject<T>

Starts tracking a given T object.

Trait Implementations

impl<T> Clone for Inventory<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.