Struct census::Inventory

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

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

Implementations

impl<T> Inventory<T>

pub fn new() -> Inventory<T>

Creates a new inventory.

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.

use census::{Inventory, TrackedObject};

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 wait_until_empty(&self)

This function blocks until there are no more items in the inventory.

It is a helper calling

self.wait_until_predicate(|count| count == 0)

Note it is very easy to misuse this function and create a deadlock. For instance, if any living TrackedObject is on the stack at the moment of the call, it will not get dropped, and the inventory cannot become empty.

pub fn wait_until_predicate<F: Fn(usize) -> bool>(&self, predicate_on_count: F)

This function blocks until the number of items in the repository matches a specific predicate.

See also wait_until_empty.

Note it is very easy to misuse this function and create a deadlock. For instance, if any living TrackedObject is on the stack at the moment of the call, it will not get dropped, and the inventory cannot become empty.

pub fn track(&self, item: 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.

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

Performs copy-assignment from source.

impl<T> Default for Inventory<T>

fn default() -> Self

Returns the “default value” for a type.