Struct tinyset::set::Set
[−]
[src]
pub struct Set<T: Copy + Eq + Hash> { /* fields omitted */ }
A set that is a FnvHashSet
when it has many elements, but is just
an array for small set sizes.
As with the FnvHashSet
type, a Set
requires that the
elements implement the Eq and Hash traits. This can frequently be
achieved by using #[derive(PartialEq, Eq, Hash)]. In addition,
Set
requires that the elements implement the Copy
trait,
and really they should be pretty small, since Set always
stores room for CAPACITY
elements.
Methods
impl<T: Copy + Eq + Hash> Set<T>
[src]
fn new() -> Set<T>
Creates an empty set..
fn default() -> Set<T>
Creates an empty set..
fn with_capacity(cap: usize) -> Set<T>
Creates an empty set with the specified capacity.
fn len(&self) -> usize
Returns the number of elements in the set.
fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional
more elements to be
inserted in the set. The collection may reserve more space
to avoid frequent reallocations.
fn insert(&mut self, elem: T) -> 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.
fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where
T: Borrow<Q>,
Q: Hash + Eq,
T: Borrow<Q>,
Q: Hash + Eq,
Removes an element, and returns true if that element was present.
fn contains<Q: ?Sized>(&self, value: &Q) -> bool where
T: Borrow<Q>,
Q: Hash + Eq,
T: Borrow<Q>,
Q: Hash + Eq,
Returns true if the set contains a value.
fn iter(&self) -> Iter<T>
Returns an iterator over the set.
fn drain(&mut self) -> IntoIter<T>
Clears the set, returning all elements in an iterator.
Trait Implementations
impl<T: Debug + Copy + Eq + Hash> Debug for Set<T>
[src]
impl<T: Clone + Copy + Eq + Hash> Clone for Set<T>
[src]
fn clone(&self) -> Set<T>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<T: Hash + Copy + Eq> FromIterator<T> for Set<T>
[src]
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
Creates a value from an iterator. Read more
impl<'a, T: Eq + Hash + Copy> IntoIterator for &'a Set<T>
[src]
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Iter<'a, T>
Creates an iterator from a value. Read more
impl<T: Eq + Hash + Copy> IntoIterator for Set<T>
[src]
type Item = T
The type of the elements being iterated over.
type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> IntoIter<T>
Creates a consuming iterator, that is, one that moves each value out of the set in arbitrary order. The set cannot be used after calling this.
Examples
use tinyset::Set; let mut set: Set<u32> = Set::new(); set.insert(2); set.insert(5); // Not possible to collect to a Vec<String> with a regular `.iter()`. let v: Vec<_> = set.into_iter().collect(); // Will print in an arbitrary order. for x in &v { println!("{}", x); }
impl<'a, 'b, T: Eq + Hash + Copy> Sub<&'b Set<T>> for &'a Set<T>
[src]
type Output = Set<T>
The resulting type after applying the -
operator
fn sub(self, rhs: &Set<T>) -> Set<T>
Returns the difference of self
and rhs
as a new Set<T>
.
Examples
use tinyset::Set; let a: Set<u32> = vec![1, 2, 3].into_iter().collect(); let b: Set<u32> = vec![3, 4, 5].into_iter().collect(); let set = &a - &b; let mut i = 0; let expected = [1, 2]; for x in &set { assert!(expected.contains(x)); i += 1; } assert_eq!(i, expected.len());
impl<T: Eq + Hash + Copy> Extend<T> for Set<T>
[src]
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
Adds a bunch of elements to the set
Examples
use tinyset::Set; let mut a: Set<u32> = vec![1, 2, 3].into_iter().collect(); a.extend(vec![3, 4, 5]); let mut i = 0; let expected = [1, 2, 3, 4, 5]; for x in &a { assert!(expected.contains(x)); i += 1; } assert_eq!(i, expected.len());
impl<'a, 'b, T: Eq + Hash + Copy> BitOr<&'b Set<T>> for &'a Set<T>
[src]
type Output = Set<T>
The resulting type after applying the |
operator
fn bitor(self, rhs: &Set<T>) -> Set<T>
Returns the union of self
and rhs
as a new Set<T>
.
Examples
use tinyset::Set; let a: Set<u32> = vec![1, 2, 3].into_iter().collect(); let b: Set<u32> = vec![3, 4, 5].into_iter().collect(); let set = &a | &b; let mut i = 0; let expected = [1, 2, 3, 4, 5]; for x in &set { assert!(expected.contains(x)); i += 1; } assert_eq!(i, expected.len());