Struct GPieces 

pub struct GPieces(/* private fields */);

Implementations

impl GPieces

pub fn get_mut(&mut self, piece: PieceId) -> Option<&mut GPiece>

pub fn values_mut(&mut self) -> ValuesMut<'_, PieceId, GPiece>

pub fn as_mut( &mut self, _: ModifyingPieces, ) -> &mut DenseSlotMap<PieceId, GPiece>

Methods from Deref<Target = DenseSlotMap<PieceId, GPiece>>

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 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 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 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);

Trait Implementations

impl ById for GPieces

type Id = PieceId

type Entry = GPiece

type Error = Inapplicable

fn byid(&self, piece: PieceId) -> Result<&GPiece, Inapplicable>

fn byid_mut(&mut self, piece: PieceId) -> Result<&mut GPiece, Inapplicable>

impl Debug for GPieces

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

Formats the value using the given formatter.

impl Default for GPieces

fn default() -> GPieces

Returns the “default value” for a type.

impl Deref for GPieces

type Target = DenseSlotMap<PieceId, GPiece>

The resulting type after dereferencing.

fn deref(&self) -> &<GPieces as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for GPieces

fn deserialize<__D>( __deserializer: __D, ) -> Result<GPieces, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'p> IntoIterator for &'p mut GPieces

type Item = (PieceId, &'p mut GPiece)

The type of the elements being iterated over.

type IntoIter = IterMut<'p, PieceId, GPiece>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'p mut GPieces as IntoIterator>::IntoIter

Creates an iterator from a value.

impl Serialize for GPieces

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

where __S: Serializer,

Serialize this value into the given Serde serializer.