pub struct Inventory<T> { /* private fields */ }
Expand description
The Inventory
register and keeps track of all of the objects alive.
Implementations§
source§impl<T> Inventory<T>
impl<T> Inventory<T>
sourcepub fn list(&self) -> Vec<TrackedObject<T>>
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());
sourcepub fn wait_until_empty(&self)
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.
sourcepub fn wait_until_predicate<F: Fn(usize) -> bool>(&self, predicate_on_count: F)
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.
sourcepub fn track(&self, item: T) -> TrackedObject<T>
pub fn track(&self, item: T) -> TrackedObject<T>
Starts tracking a given T
object.