Struct Reports 

pub struct Reports {
    pub reports: DenseSlotMap<ReportId, Report>,
}

Fields

reports: DenseSlotMap<ReportId, Report>

Implementations

impl Reports

pub fn create(&mut self, report: Report) -> ReportId

pub fn cleanup(&mut self, current_time: TimeOfDay)

Methods from Deref<Target = DenseSlotMap<ReportId, Report>>

pub fn len(&self) -> usize

Returns the number of elements in the slot map.

Examples

let mut sm = DenseSlotMap::with_capacity(10);
sm.insert("len() counts actual elements, not capacity");
let key = sm.insert("removed elements don't count either");
sm.remove(key);
assert_eq!(sm.len(), 1);

pub fn is_empty(&self) -> bool

Returns if the slot map is empty.

Examples

let mut sm = DenseSlotMap::new();
let key = sm.insert("dummy");
assert_eq!(sm.is_empty(), false);
sm.remove(key);
assert_eq!(sm.is_empty(), true);

pub fn capacity(&self) -> usize

Returns the number of elements the DenseSlotMap can hold without reallocating.

Examples

let sm: DenseSlotMap<_, f64> = DenseSlotMap::with_capacity(10);
assert_eq!(sm.capacity(), 10);

pub fn contains_key(&self, key: K) -> bool

Returns true if the slot map contains key.

Examples

let mut sm = DenseSlotMap::new();
let key = sm.insert(42);
assert_eq!(sm.contains_key(key), true);
sm.remove(key);
assert_eq!(sm.contains_key(key), false);

pub fn get(&self, key: K) -> Option<&V>

Returns a reference to the value corresponding to the key.

Examples

let mut sm = DenseSlotMap::new();
let key = sm.insert("bar");
assert_eq!(sm.get(key), Some(&"bar"));
sm.remove(key);
assert_eq!(sm.get(key), None);

pub unsafe fn get_unchecked(&self, key: K) -> &V

Returns a reference to the value corresponding to the key without version or bounds checking.

Safety

This should only be used if contains_key(key) is true. Otherwise it is potentially unsafe.

Examples

let mut sm = DenseSlotMap::new();
let key = sm.insert("bar");
assert_eq!(unsafe { sm.get_unchecked(key) }, &"bar");
sm.remove(key);
// sm.get_unchecked(key) is now dangerous!

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all key-value pairs in an arbitrary order. The iterator element type is (K, &'a V).

Examples

let mut sm = DenseSlotMap::new();
let k0 = sm.insert(0);
let k1 = sm.insert(1);
let k2 = sm.insert(2);

let mut it = sm.iter();
for (k, v) in sm.iter() {
    println!("key: {:?}, val: {}", k, v);
}

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in an arbitrary order. The iterator element type is K.

Examples

let mut sm = DenseSlotMap::new();
let k0 = sm.insert(10);
let k1 = sm.insert(20);
let k2 = sm.insert(30);
let keys: HashSet<_> = sm.keys().collect();
let check: HashSet<_> = vec![k0, k1, k2].into_iter().collect();
assert_eq!(keys, check);

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in an arbitrary order. The iterator element type is &'a V.

Examples

let mut sm = DenseSlotMap::new();
let k0 = sm.insert(10);
let k1 = sm.insert(20);
let k2 = sm.insert(30);
let values: HashSet<_> = sm.values().collect();
let check: HashSet<_> = vec![&10, &20, &30].into_iter().collect();
assert_eq!(values, check);

pub fn keys_as_slice(&self) -> &[K]

Returns a slice containing all keys in the slot map in an arbitrary order (but in the same order as values_as_slice).

Examples

let mut sm = DenseSlotMap::new();
let k1 = sm.insert(1);
let k2 = sm.insert(2);
sm.remove(k1);
sm.insert(3);
let key_slice = sm.keys_as_slice();
// The order is arbitrary, but we can check if the keys are present.
assert!(key_slice.contains(&k2));
assert_eq!(key_slice.len(), 2);
// The keys correspond to the values.
assert_eq!(sm.values_as_slice()[0], sm[key_slice[0]]);

pub fn values_as_slice(&self) -> &[V]

Returns a slice containing all values in the slot map in an arbitrary order (but in the same order as keys_as_slice).

Examples

let mut sm = DenseSlotMap::new();
sm.insert(10);
sm.insert(20);
sm.insert(30);
let value_slice = sm.values_as_slice();
let values: HashSet<_> = value_slice.iter().collect();
let check: HashSet<_> = vec![&10, &20, &30].into_iter().collect();
assert_eq!(values, check);
// The keys correspond to the values.
assert_eq!(value_slice[0], sm[sm.keys_as_slice()[0]]);

pub fn as_slices(&self) -> (&[K], &[V])

Returns slices containing all keys and values in the slot map in an arbitrary order (but in the same order for both slices).

Examples

let mut sm = DenseSlotMap::new();
sm.insert(10);
sm.insert(8);
sm.insert(6);
let (keys, values) = sm.as_slices();
for (k, v) in keys.iter().zip(values) {
    assert_eq!(sm[*k], *v);
}

Trait Implementations

impl Clone for Reports

fn clone(&self) -> Reports

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Reports

fn default() -> Reports

Returns the “default value” for a type.

impl Deref for Reports

type Target = DenseSlotMap<ReportId, Report>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for Reports

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Reports

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.