Struct fixed_map::map::Map [−][src]
pub struct Map<K, V> where
K: Key<K, V>, { /* fields omitted */ }
Expand description
A fixed map with a predetermined size.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Part { One, Two, } #[derive(Clone, Copy, Key)] enum Key { Simple, Composite(Part), String(&'static str), Number(u32), Singleton(()), Option(Option<Part>), Boolean(bool), } let mut map = Map::new(); map.insert(Key::Simple, 1); map.insert(Key::Composite(Part::One), 2); map.insert(Key::String("foo"), 3); map.insert(Key::Number(1), 4); map.insert(Key::Singleton(()), 5); map.insert(Key::Option(None), 6); map.insert(Key::Option(Some(Part::One)), 7); map.insert(Key::Boolean(true), 8); assert_eq!(map.get(Key::Simple), Some(&1)); assert_eq!(map.get(Key::Composite(Part::One)), Some(&2)); assert_eq!(map.get(Key::Composite(Part::Two)), None); assert_eq!(map.get(Key::String("foo")), Some(&3)); assert_eq!(map.get(Key::String("bar")), None); assert_eq!(map.get(Key::Number(1)), Some(&4)); assert_eq!(map.get(Key::Number(2)), None); assert_eq!(map.get(Key::Singleton(())), Some(&5)); assert_eq!(map.get(Key::Option(None)), Some(&6)); assert_eq!(map.get(Key::Option(Some(Part::One))), Some(&7)); assert_eq!(map.get(Key::Option(Some(Part::Two))), None); assert_eq!(map.get(Key::Boolean(true)), Some(&8)); assert_eq!(map.get(Key::Boolean(false)), None);
Storing references:
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, Key)] enum Key { First, Second, } let mut map = Map::new(); let a = 42u32; map.insert(Key::First, &a); assert_eq!(map.values().cloned().collect::<Vec<_>>(), vec![&42u32]);
Implementations
impl<K, V> Map<K, V> where
K: Key<K, V>,
[src]
impl<K, V> Map<K, V> where
K: Key<K, V>,
[src]A map implementation that uses fixed storage.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut m = Map::new(); m.insert(Key::One, 1); assert_eq!(m.get(Key::One), Some(&1)); assert_eq!(m.get(Key::Two), None);
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Part { A, B, } #[derive(Clone, Copy, Key)] enum Key { Simple, Composite(Part), } let mut m = Map::new(); m.insert(Key::Simple, 1); m.insert(Key::Composite(Part::A), 2); assert_eq!(m.get(Key::Simple), Some(&1)); assert_eq!(m.get(Key::Composite(Part::A)), Some(&2)); assert_eq!(m.get(Key::Composite(Part::B)), None);
pub fn new() -> Map<K, V>
[src]
pub fn new() -> Map<K, V>
[src]Creates an empty Map
.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map: Map<Key, i32> = Map::new();
pub fn keys<'a>(&'a self) -> Keys<'a, K, V>ⓘ
[src]
pub fn keys<'a>(&'a self) -> Keys<'a, K, V>ⓘ
[src]An iterator visiting all keys in arbitrary order.
The iterator element type is K
.
Examples
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Key)] pub enum Key { One, Two, Three, } let mut map = Map::new(); map.insert(Key::One, 1); map.insert(Key::Two, 2); assert_eq!(map.keys().collect::<Vec<_>>(), vec![Key::One, Key::Two]);
pub fn values<'a>(&'a self) -> Values<'a, K, V>ⓘ
[src]
pub fn values<'a>(&'a self) -> Values<'a, K, V>ⓘ
[src]An iterator visiting all values in arbitrary order.
The iterator element type is &'a V
.
Examples
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Key)] pub enum Key { One, Two, Three, } let mut map = Map::new(); map.insert(Key::One, 1); map.insert(Key::Two, 2); assert_eq!(map.values().map(|v| *v).collect::<Vec<_>>(), vec![1, 2]);
pub fn values_mut<'a>(&'a mut self) -> ValuesMut<'a, K, V>ⓘ
[src]
pub fn values_mut<'a>(&'a mut self) -> ValuesMut<'a, K, V>ⓘ
[src]An iterator visiting all values mutably in arbitrary order.
The iterator element type is &'a mut V
.
Examples
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Key)] pub enum Key { One, Two, Three, } let mut map = Map::new(); map.insert(Key::One, 1); map.insert(Key::Two, 2); for val in map.values_mut() { *val += 10; } assert_eq!(map.values().map(|v| *v).collect::<Vec<_>>(), vec![11, 12]);
pub fn iter<'a>(&'a self) -> Iter<'a, K, V>ⓘ
[src]
pub fn iter<'a>(&'a self) -> Iter<'a, K, V>ⓘ
[src]An iterator visiting all key-value pairs in arbitrary order.
The iterator element type is (K, &'a V)
.
Examples
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Key)] enum Key { One, Two, Three, } let mut map = Map::new(); map.insert(Key::One, 1); map.insert(Key::Two, 2); assert_eq!(map.iter().collect::<Vec<_>>(), vec![(Key::One, &1), (Key::Two, &2)]);
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, K, V>ⓘ
[src]
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, K, V>ⓘ
[src]An iterator visiting all key-value pairs in arbitrary order,
with mutable references to the values.
The iterator element type is (K, &'a mut V)
.
Examples
use fixed_map::{Key, Map}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Key)] enum Key { One, Two, Three, } let mut map = Map::new(); map.insert(Key::One, 1); map.insert(Key::Two, 2); // Update all values for (_, val) in map.iter_mut() { *val *= 2; } assert_eq!(map.iter().collect::<Vec<_>>(), vec![(Key::One, &2), (Key::Two, &4)]);
pub fn get(&self, key: K) -> Option<&V>
[src]
pub fn get(&self, key: K) -> Option<&V>
[src]Returns a reference to the value corresponding to the key.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map = Map::new(); map.insert(Key::One, "a"); assert_eq!(map.get(Key::One), Some(&"a")); assert_eq!(map.get(Key::Two), None);
pub fn get_mut(&mut self, key: K) -> Option<&mut V>
[src]
pub fn get_mut(&mut self, key: K) -> Option<&mut V>
[src]Returns a mutable reference to the value corresponding to the key.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map = Map::new(); map.insert(Key::One, "a"); if let Some(x) = map.get_mut(Key::One) { *x = "b"; } assert_eq!(map.get(Key::One), Some(&"b"));
pub fn insert(&mut self, key: K, value: V) -> Option<V>
[src]
pub fn insert(&mut self, key: K, value: V) -> Option<V>
[src]Inserts a key-value pair into the map.
If the map did not have this key present, None
is returned.
If the map did have this key present, the value is updated, and the old value is returned.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map = Map::new(); assert_eq!(map.insert(Key::One, "a"), None); assert_eq!(map.is_empty(), false); map.insert(Key::Two, "b"); assert_eq!(map.insert(Key::Two, "c"), Some("b")); assert_eq!(map.get(Key::Two), Some(&"c"));
pub fn remove(&mut self, key: K) -> Option<V>
[src]
pub fn remove(&mut self, key: K) -> Option<V>
[src]Removes a key from the map, returning the value at the key if the key was previously in the map.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map = Map::new(); map.insert(Key::One, "a"); assert_eq!(map.remove(Key::One), Some("a")); assert_eq!(map.remove(Key::One), None);
pub fn clear(&mut self)
[src]
pub fn clear(&mut self)
[src]Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.
Examples
use fixed_map::{Key, Map}; #[derive(Clone, Copy, Key)] enum Key { One, Two, } let mut map = Map::new(); map.insert(Key::One, "a"); map.clear(); assert!(map.is_empty());
Trait Implementations
impl<'de, K, V> Deserialize<'de> for Map<K, V> where
K: Key<K, V> + Deserialize<'de>,
V: Deserialize<'de>,
[src]
impl<'de, K, V> Deserialize<'de> for Map<K, V> where
K: Key<K, V> + Deserialize<'de>,
V: Deserialize<'de>,
[src]fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]Deserialize this value from the given Serde deserializer. Read more
impl<K, V> Eq for Map<K, V> where
K: Key<K, V>,
K::Storage: Eq,
[src]
K: Key<K, V>,
K::Storage: Eq,
Auto Trait Implementations
impl<K, V> RefUnwindSafe for Map<K, V> where
<K as Key<K, V>>::Storage: RefUnwindSafe,
<K as Key<K, V>>::Storage: RefUnwindSafe,
impl<K, V> Send for Map<K, V> where
<K as Key<K, V>>::Storage: Send,
<K as Key<K, V>>::Storage: Send,
impl<K, V> Sync for Map<K, V> where
<K as Key<K, V>>::Storage: Sync,
<K as Key<K, V>>::Storage: Sync,
impl<K, V> Unpin for Map<K, V> where
<K as Key<K, V>>::Storage: Unpin,
<K as Key<K, V>>::Storage: Unpin,
impl<K, V> UnwindSafe for Map<K, V> where
<K as Key<K, V>>::Storage: UnwindSafe,
<K as Key<K, V>>::Storage: UnwindSafe,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,