# [−] [src] Struct heapless::IndexSet

    pub struct IndexSet<T, N, S> where
        T: Eq + Hash,
        N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,  { /* fields omitted */ }

Fixed capacity `IndexSet`.

Note that you cannot use `IndexSet` directly, since it is generic around the hashing algorithm in use. Pick a concrete instantiation like `FnvIndexSet` instead or create your own.

Note that the capacity of the `IndexSet` must be a power of 2.

# Examples

Since `IndexSet` cannot be used directly, we're using its `FnvIndexSet` instantiation for this example.

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    // A hash set with a capacity of 16 elements allocated on the stack
    let mut books = FnvIndexSet::<_, U16>::new();

    // Add some books.
    books.insert("A Dance With Dragons").unwrap();
    books.insert("To Kill a Mockingbird").unwrap();
    books.insert("The Odyssey").unwrap();
    books.insert("The Great Gatsby").unwrap();

    // Check for a specific one.
    if !books.contains("The Winds of Winter") {
        println!("We have {} books, but The Winds of Winter ain't one.",
                 books.len());
    }

    // Remove a book.
    books.remove("The Odyssey");

    // Iterate over everything.
    for book in &books {
        println!("{}", book);
    }

## Implementations

### `impl<T, N, S> IndexSet<T, N, BuildHasherDefault<S>> where
T: Eq + Hash,
S: Default + Hasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>> + PowerOfTwo,` [src]

#### `pub fn new() -> Self` [src]

Creates an empty `IndexSet`

### `impl<T, N, S> IndexSet<T, N, S> where
T: Eq + Hash,
S: BuildHasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `pub fn capacity(&self) -> usize` [src]

Returns the number of elements the set can hold

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let set = FnvIndexSet::<i32, U16>::new();
    assert_eq!(set.capacity(), 16);

#### `pub fn iter(&self) -> Iter<'_, T>` [src]

Return an iterator over the values of the set, in their order

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut set = FnvIndexSet::<_, U16>::new();
    set.insert("a").unwrap();
    set.insert("b").unwrap();

    // Will print in an arbitrary order.
    for x in set.iter() {
        println!("{}", x);
    }

#### `pub fn difference<'a, N2, S2>(
&'a self,
other: &'a IndexSet<T, N2, S2>
) -> Difference<'a, T, N2, S2> where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Visits the values representing the difference, i.e. the values that are in `self` but not in `other`.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut a: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut b: FnvIndexSet<_, U16> = [4, 2, 3, 4].iter().cloned().collect();

    // Can be seen as `a - b`.
    for x in a.difference(&b) {
        println!("{}", x); // Print 1
    }

    let diff: FnvIndexSet<_, U16> = a.difference(&b).collect();
    assert_eq!(diff, [1].iter().collect::<FnvIndexSet<_, U16>>());

    // Note that difference is not symmetric,
    // and `b - a` means something else:
    let diff: FnvIndexSet<_, U16> = b.difference(&a).collect();
    assert_eq!(diff, [4].iter().collect::<FnvIndexSet<_, U16>>());

#### `pub fn symmetric_difference<'a, N2, S2>(
&'a self,
other: &'a IndexSet<T, N2, S2>
) -> impl Iterator<Item = &'a T> where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Visits the values representing the symmetric difference, i.e. the values that are in `self` or in `other` but not in both.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut a: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut b: FnvIndexSet<_, U16> = [4, 2, 3, 4].iter().cloned().collect();

    // Print 1, 4 in that order order.
    for x in a.symmetric_difference(&b) {
        println!("{}", x);
    }

    let diff1: FnvIndexSet<_, U16> = a.symmetric_difference(&b).collect();
    let diff2: FnvIndexSet<_, U16> = b.symmetric_difference(&a).collect();

    assert_eq!(diff1, diff2);
    assert_eq!(diff1, [1, 4].iter().collect::<FnvIndexSet<_, U16>>());

#### `pub fn intersection<'a, N2, S2>(
&'a self,
other: &'a IndexSet<T, N2, S2>
) -> Intersection<'a, T, N2, S2> where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Visits the values representing the intersection, i.e. the values that are both in `self` and `other`.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut a: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut b: FnvIndexSet<_, U16> = [4, 2, 3, 4].iter().cloned().collect();

    // Print 2, 3 in that order.
    for x in a.intersection(&b) {
        println!("{}", x);
    }

    let intersection: FnvIndexSet<_, U16> = a.intersection(&b).collect();
    assert_eq!(intersection, [2, 3].iter().collect::<FnvIndexSet<_, U16>>());

#### `pub fn union<'a, N2, S2>(
&'a self,
other: &'a IndexSet<T, N2, S2>
) -> impl Iterator<Item = &'a T> where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Visits the values representing the union, i.e. all the values in `self` or `other`, without duplicates.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut a: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut b: FnvIndexSet<_, U16> = [4, 2, 3, 4].iter().cloned().collect();

    // Print 1, 2, 3, 4 in that order.
    for x in a.union(&b) {
        println!("{}", x);
    }

    let union: FnvIndexSet<_, U16> = a.union(&b).collect();
    assert_eq!(union, [1, 2, 3, 4].iter().collect::<FnvIndexSet<_, U16>>());

#### `pub fn len(&self) -> usize` [src]

Returns the number of elements in the set.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut v: FnvIndexSet<_, U16> = FnvIndexSet::new();
    assert_eq!(v.len(), 0);
    v.insert(1).unwrap();
    assert_eq!(v.len(), 1);

#### `pub fn is_empty(&self) -> bool` [src]

Returns `true` if the set contains no elements.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut v: FnvIndexSet<_, U16> = FnvIndexSet::new();
    assert!(v.is_empty());
    v.insert(1).unwrap();
    assert!(!v.is_empty());

#### `pub fn clear(&mut self)` [src]

Clears the set, removing all values.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut v: FnvIndexSet<_, U16> = FnvIndexSet::new();
    v.insert(1).unwrap();
    v.clear();
    assert!(v.is_empty());

#### `pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool where
T: Borrow<Q>,
Q: Eq + Hash,` [src]

Returns `true` if the set contains a value.

The value may be any borrowed form of the set's value type, but `Hash` and `Eq` on the borrowed form must match those for the value type.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let set: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    assert_eq!(set.contains(&1), true);
    assert_eq!(set.contains(&4), false);

#### `pub fn is_disjoint<N2, S2>(&self, other: &IndexSet<T, N2, S2>) -> bool where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Returns `true` if `self` has no elements in common with `other`. This is equivalent to checking for an empty intersection.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let a: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut b = FnvIndexSet::<_, U16>::new();

    assert_eq!(a.is_disjoint(&b), true);
    b.insert(4).unwrap();
    assert_eq!(a.is_disjoint(&b), true);
    b.insert(1).unwrap();
    assert_eq!(a.is_disjoint(&b), false);

#### `pub fn is_subset<N2, S2>(&self, other: &IndexSet<T, N2, S2>) -> bool where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

Returns `true` if the set is a subset of another, i.e. `other` contains at least all the values in `self`.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let sup: FnvIndexSet<_, U16> = [1, 2, 3].iter().cloned().collect();
    let mut set = FnvIndexSet::<_, U16>::new();

    assert_eq!(set.is_subset(&sup), true);
    set.insert(2).unwrap();
    assert_eq!(set.is_subset(&sup), true);
    set.insert(4).unwrap();
    assert_eq!(set.is_subset(&sup), false);

#### `pub fn is_superset<N2, S2>(&self, other: &IndexSet<T, N2, S2>) -> bool where
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
S2: BuildHasher,` [src]

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let sub: FnvIndexSet<_, U16> = [1, 2].iter().cloned().collect();
    let mut set = FnvIndexSet::<_, U16>::new();

    assert_eq!(set.is_superset(&sub), false);

    set.insert(0).unwrap();
    set.insert(1).unwrap();
    assert_eq!(set.is_superset(&sub), false);

    set.insert(2).unwrap();
    assert_eq!(set.is_superset(&sub), true);

#### `pub fn insert(&mut self, value: T) -> Result<bool, T>` [src]

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 heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut set = FnvIndexSet::<_, U16>::new();

    assert_eq!(set.insert(2).unwrap(), true);
    assert_eq!(set.insert(2).unwrap(), false);
    assert_eq!(set.len(), 1);

#### `pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where
T: Borrow<Q>,
Q: Eq + Hash,` [src]

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

The value may be any borrowed form of the set's value type, but `Hash` and `Eq` on the borrowed form must match those for the value type.

# Examples

    use heapless::FnvIndexSet;
    use heapless::consts::*;

    let mut set = FnvIndexSet::<_, U16>::new();

    set.insert(2).unwrap();
    assert_eq!(set.remove(&2), true);
    assert_eq!(set.remove(&2), false);

## Trait Implementations

### `impl<T, N, S> Clone for IndexSet<T, N, S> where
T: Eq + Hash + Clone,
S: Clone,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn clone(&self) -> Self` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<T, N, S> Debug for IndexSet<T, N, S> where
T: Eq + Hash + Debug,
S: BuildHasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<T, N, S> Default for IndexSet<T, N, S> where
T: Eq + Hash,
S: BuildHasher + Default,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn default() -> Self` [src]

Returns the "default value" for a type. Read more

### `impl<'a, T, N, S> Extend<&'a T> for IndexSet<T, N, S> where
T: 'a + Eq + Hash + Copy,
S: BuildHasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a T>,` [src]

Extends a collection with the contents of an iterator. Read more

#### `pub fn extend_one(&mut self, item: A)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

#### `pub fn extend_reserve(&mut self, additional: usize)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Reserves capacity in a collection for the given number of additional elements. Read more

### `impl<T, N, S> Extend<T> for IndexSet<T, N, S> where
T: Eq + Hash,
S: BuildHasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = T>,` [src]

Extends a collection with the contents of an iterator. Read more

#### `pub fn extend_one(&mut self, item: A)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

#### `pub fn extend_reserve(&mut self, additional: usize)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Reserves capacity in a collection for the given number of additional elements. Read more

### `impl<T, N, S> FromIterator<T> for IndexSet<T, N, S> where
T: Eq + Hash,
S: BuildHasher + Default,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,` [src]

Creates a value from an iterator. Read more

### `impl<'a, T, N, S> IntoIterator for &'a IndexSet<T, N, S> where
T: Eq + Hash,
S: BuildHasher,
N: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [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) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<T, N1, N2, S1, S2> PartialEq<IndexSet<T, N2, S2>> for IndexSet<T, N1, S1> where
T: Eq + Hash,
S1: BuildHasher,
S2: BuildHasher,
N1: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,
N2: ArrayLength<Bucket<T, ()>> + ArrayLength<Option<Pos>>,` [src]

#### `fn eq(&self, other: &IndexSet<T, N2, S2>) -> bool` [src]

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

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

## Auto Trait Implementations

### `impl<T, N, S> Send for IndexSet<T, N, S> where
S: Send,
T: Send,` [src]

### `impl<T, N, S> Sync for IndexSet<T, N, S> where
S: Sync,
T: Sync,` [src]

### `impl<T, N, S> Unpin for IndexSet<T, N, S> where
S: Unpin,
<N as ArrayLength<Bucket<T, ()>>>::ArrayType: Unpin,
<N as ArrayLength<Option<Pos>>>::ArrayType: Unpin,` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> Same<T> for T` [src]

#### `type Output = T`

Should always be `Self`

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.