pub struct Set<K> where
K: Key<K, ()>, { /* fields omitted */ }
A fixed set implemented as a Map
where the value is ()
.
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)));
A map implementation that uses fixed storage.
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);
Creates an empty Set
.
use fixed_map::{Key, Set};
#[derive(Clone, Copy, Key)]
enum Key {
One,
Two,
}
let set: Set<Key> = Set::new();
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
.
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]);
Returns true
if the set contains a value.
Returns a reference to the value corresponding to the key.
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);
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.
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);
Removes a value from the set. Returns true
if the value was
present in the set.
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);
Clears the set, removing all values.
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());
Returns true if the set contains no elements.
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());
Returns the number of elements in the set.
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);
This method tests for self
and other
values to be equal, and is used by ==
. Read more
This method tests for !=
.
Performs copy-assignment from source
. Read more
Returns the "default value" for a type. Read more
Formats the value using the given formatter. Read more
Creates owned data from borrowed data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Immutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (get_type_id
)
this method will likely be replaced by an associated static
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Mutably borrows from an owned value. Read more