Struct fixed_map::set::Set

pub struct Set<K> where
    K: Key<K, ()>,  { /* fields omitted */ }

A fixed set implemented as a Map where the value is ().

Examples

use fixed_map::{Key, Set};

#[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 set = Set::new();

set.insert(Key::Simple);
set.insert(Key::Composite(Part::One));
set.insert(Key::String("foo"));
set.insert(Key::Number(1));
set.insert(Key::Singleton(()));
set.insert(Key::Option(None));
set.insert(Key::Option(Some(Part::One)));
set.insert(Key::Boolean(true));

assert!(set.contains(Key::Simple));
assert!(set.contains(Key::Composite(Part::One)));
assert!(!set.contains(Key::Composite(Part::Two)));
assert!(set.contains(Key::String("foo")));
assert!(!set.contains(Key::String("bar")));
assert!(set.contains(Key::Number(1)));
assert!(!set.contains(Key::Number(2)));
assert!(set.contains(Key::Singleton(())));
assert!(set.contains(Key::Option(None)));
assert!(set.contains(Key::Option(Some(Part::One))));
assert!(!set.contains(Key::Option(Some(Part::Two))));
assert!(set.contains(Key::Boolean(true)));
assert!(!set.contains(Key::Boolean(false)));

Implementations

impl<K> Set<K> where
    K: Key<K, ()>, 

A map implementation that uses fixed storage.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut m = Set::new();
m.insert(Key::One);

assert_eq!(m.contains(Key::One), true);
assert_eq!(m.contains(Key::Two), false);

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Part {
    A,
    B,
}

#[derive(Clone, Copy, Key)]
enum Key {
    Simple,
    Composite(Part),
}

let mut m = Set::new();
m.insert(Key::Simple);
m.insert(Key::Composite(Part::A));

assert_eq!(m.contains(Key::Simple), true);
assert_eq!(m.contains(Key::Composite(Part::A)), true);
assert_eq!(m.contains(Key::Composite(Part::B)), false);

pub fn new() -> Set<K>

Creates an empty Set.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let set: Set<Key> = Set::new();

pub fn iter(&self) -> Iter<K>

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

Because of limitations in how Rust can express lifetimes through traits, this method will first pre-allocate a vector to store all references.

For a zero-cost version of this function, see Set::iter_fn.

Examples

use fixed_map::{Key, Set};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
enum Key {
    One,
    Two,
    Three,
}

let mut map = Set::new();
map.insert(Key::One);
map.insert(Key::Two);

assert_eq!(map.iter().collect::<Vec<_>>(), vec![Key::One, Key::Two]);

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

Returns true if the set contains a value. Returns a reference to the value corresponding to the key.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Set::new();
map.insert(Key::One);
assert_eq!(map.contains(Key::One), true);
assert_eq!(map.contains(Key::Two), false);

pub fn insert(&mut self, value: K) -> bool

Adds a value to the set.

If the set did not have this value present, true is returned.

If the set did have this value present, false is returned.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut set = Set::new();
assert_eq!(set.insert(Key::One), true);
assert_eq!(set.is_empty(), false);

set.insert(Key::Two);
assert_eq!(set.insert(Key::Two), false);
assert_eq!(set.contains(Key::Two), true);

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

Removes a value from the set. Returns true if the value was present in the set.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut set = Set::new();
set.insert(Key::One);
assert_eq!(set.remove(Key::One), true);
assert_eq!(set.remove(Key::One), false);

pub fn clear(&mut self)

Clears the set, removing all values.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut set = Set::new();
set.insert(Key::One);
set.clear();
assert!(set.is_empty());

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut set = Set::new();
assert!(set.is_empty());
set.insert(Key::One);
assert!(!set.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the set.

Examples

use fixed_map::{Key, Set};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut set = Set::new();
assert_eq!(set.len(), 0);
set.insert(Key::One);
assert_eq!(set.len(), 1);

Trait Implementations

impl<K> Clone for Set<K> where
    K: Key<K, ()>,
    K::Storage: Clone, 

fn clone(&self) -> Set<K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K> Debug for Set<K> where
    K: Key<K, ()> + Debug, 

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

Formats the value using the given formatter.

impl<K> Default for Set<K> where
    K: Key<K, ()>, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K> Deserialize<'de> for Set<K> where
    K: Key<K, ()> + Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K> PartialEq<Set<K>> for Set<K> where
    K: Key<K, ()>,
    K::Storage: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<K> Serialize for Set<K> where
    K: Key<K, ()> + Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<K> Eq for Set<K> where
    K: Key<K, ()>,
    K::Storage: Eq,