Struct scapegoat::SGSet

pub struct SGSet<T: Ord> { /* fields omitted */ }

Ordered set. API examples and descriptions are all adapted or directly copied from the standard library’s BTreeSet.

Implementations

impl<T: Ord> SGSet<T>

pub fn new() -> Self

Constructor.

Examples

use scapegoat::SGSet;

let mut set: SGSet<i32> = SGSet::new();

pub fn capacity(&self) -> usize

#![no_std]: total capacity, e.g. maximum number of set elements. Attempting to insert elements beyond capacity will panic.

If using std: fast capacity, e.g. number of set elements stored on the stack. Elements inserted beyond capacity will be stored on the heap.

Examples

use scapegoat::SGSet;

let mut set: SGSet<i32> = SGSet::new();

assert!(set.capacity() > 0)

pub fn append(&mut self, other: &mut SGSet<T>)

Moves all elements from other into self, leaving other empty.

Examples

use scapegoat::SGSet;

let mut a = SGSet::new();
a.insert(1);
a.insert(2);
a.insert(3);

let mut b = SGSet::new();
b.insert(3);
b.insert(4);
b.insert(5);

a.append(&mut b);

assert_eq!(a.len(), 5);
assert_eq!(b.len(), 0);

assert!(a.contains(&1));
assert!(a.contains(&2));
assert!(a.contains(&3));
assert!(a.contains(&4));
assert!(a.contains(&5));

pub fn insert(&mut self, value: 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, and the entry is overwritten.

Examples

use scapegoat::SGSet;

let mut set = SGSet::new();

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

pub fn iter(&self) -> Iter<'_, T>

Gets an iterator that visits the values in the SGSet in ascending order.

Examples

use scapegoat::SGSet;

let set: SGSet<usize> = [1, 2, 3].iter().cloned().collect();
let mut set_iter = set.iter();
assert_eq!(set_iter.next(), Some(&1));
assert_eq!(set_iter.next(), Some(&2));
assert_eq!(set_iter.next(), Some(&3));
assert_eq!(set_iter.next(), None);

Values returned by the iterator are returned in ascending order:

use scapegoat::SGSet;

let set: SGSet<usize> = [3, 1, 2].iter().cloned().collect();
let mut set_iter = set.iter();
assert_eq!(set_iter.next(), Some(&1));
assert_eq!(set_iter.next(), Some(&2));
assert_eq!(set_iter.next(), Some(&3));
assert_eq!(set_iter.next(), None);

pub fn remove(&mut self, value: &T) -> bool

Removes a value from the set. Returns whether the value was present in the set.

Examples

use scapegoat::SGSet;

let mut set = SGSet::new();

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

pub fn get(&self, value: &T) -> Option<&T>

Returns a reference to the value in the set, if any, that is equal to the given value.

Examples

use scapegoat::SGSet;

let set: SGSet<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);

pub fn clear(&mut self)

Clears the set, removing all values.

Examples

use scapegoat::SGSet;

let mut v = SGSet::new();
v.insert(1);
v.clear();
assert!(v.is_empty());;

pub fn contains(&self, value: &T) -> bool

Returns true if the set contains a value.

Examples

use scapegoat::SGSet;

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

pub fn first(&self) -> Option<&T>

Returns a reference to the first/minium value in the set, if any.

Examples

use scapegoat::SGSet;

let mut map = SGSet::new();
assert_eq!(map.first(), None);
map.insert(1);
assert_eq!(map.first(), Some(&1));
map.insert(2);
assert_eq!(map.first(), Some(&1));

pub fn pop_first(&mut self) -> Option<T>

Removes the first value from the set and returns it, if any. The first value is the minimum value that was in the set.

Examples

use scapegoat::SGSet;

let mut set = SGSet::new();

set.insert(1);
while let Some(n) = set.pop_first() {
    assert_eq!(n, 1);
}
assert!(set.is_empty());

pub fn last(&self) -> Option<&T>

Returns the last/maximum value in the set, if any.

Examples

use scapegoat::SGSet;

let mut map = SGSet::new();
assert_eq!(map.first(), None);
map.insert(1);
assert_eq!(map.last(), Some(&1));
map.insert(2);
assert_eq!(map.last(), Some(&2));

pub fn pop_last(&mut self) -> Option<T>

Removes the last value from the set and returns it, if any. The last value is the maximum value that was in the set.

Examples

use scapegoat::SGSet;

let mut set = SGSet::new();

set.insert(1);
while let Some(n) = set.pop_last() {
    assert_eq!(n, 1);
}
assert!(set.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the set.

Examples

use scapegoat::SGSet;

let mut v = SGSet::new();
assert_eq!(v.len(), 0);
v.insert(1);
assert_eq!(v.len(), 1);

pub fn difference(&self, other: &SGSet<T>) -> IntoIter<[&'_ T; 1024]>

Returns an iterator over values representing set difference, e.g., values in self but not in other, in ascending order.

Examples

use scapegoat::SGSet;

let mut a = SGSet::new();
a.insert(1);
a.insert(2);

let mut b = SGSet::new();
b.insert(2);
b.insert(3);

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

pub fn symmetric_difference<'a>(
    &'a self,
    other: &'a SGSet<T>
) -> IntoIter<[&'_ T; 1024]>

Returns an iterator over values representing symmetric set difference, e.g., values in self or other but not both, in ascending order.

Examples

use scapegoat::SGSet;

let mut a = SGSet::new();
a.insert(1);
a.insert(2);

let mut b = SGSet::new();
b.insert(2);
b.insert(3);

let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect();
assert_eq!(sym_diff, [1, 3]);

pub fn intersection(&self, other: &SGSet<T>) -> IntoIter<[&'_ T; 1024]>

Returns an iterator over values representing set intersection, e.g., values in both self and other, in ascending order.

Examples

use scapegoat::SGSet;

let mut a = SGSet::new();
a.insert(1);
a.insert(2);

let mut b = SGSet::new();
b.insert(2);
b.insert(3);

let intersection: Vec<_> = a.intersection(&b).cloned().collect();
assert_eq!(intersection, [2]);

pub fn union<'a>(&'a self, other: &'a SGSet<T>) -> IntoIter<[&'_ T; 1024]>

Returns an iterator over values representing set union, e.g., values in self or other, in ascending order.

Examples

use scapegoat::SGSet;

let mut a = SGSet::new();
a.insert(1);

let mut b = SGSet::new();
b.insert(2);

let union: Vec<_> = a.union(&b).cloned().collect();
assert_eq!(union, [1, 2]);

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

Examples

use scapegoat::SGSet;

let mut v = SGSet::new();
assert!(v.is_empty());
v.insert(1);
assert!(!v.is_empty());

pub fn is_disjoint(&self, other: &SGSet<T>) -> bool

Returns true if self has no elements in common with other (empty intersection).

Examples

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

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

pub fn is_subset(&self, other: &SGSet<T>) -> bool

Returns true if self is a subset of other, e.g., other contains at least all the values in self.

Examples

use scapegoat::SGSet;

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

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

pub fn is_superset(&self, other: &SGSet<T>) -> bool

Returns true if self is a superset of other, e.g., self contains at least all the values in other.

Examples

use scapegoat::SGSet;

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

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

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

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

Trait Implementations

impl<T: Ord + Clone> BitAnd<&'_ SGSet<T>> for &SGSet<T>

fn bitand(self, rhs: &SGSet<T>) -> SGSet<T>

Returns the intersection of self and rhs as a new SGSet<T>.

Examples

use scapegoat::SGSet;

let a: SGSet<_> = vec![1, 2, 3].into_iter().collect();
let b: SGSet<_> = vec![2, 3, 4].into_iter().collect();

let result = &a & &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [2, 3]);

type Output = SGSet<T>

The resulting type after applying the & operator.

impl<T: Ord + Clone> BitOr<&'_ SGSet<T>> for &SGSet<T>

fn bitor(self, rhs: &SGSet<T>) -> SGSet<T>

Returns the union of self and rhs as a new SGSet<T>.

Examples

use scapegoat::SGSet;

let a: SGSet<_> = vec![1, 2, 3].into_iter().collect();
let b: SGSet<_> = vec![3, 4, 5].into_iter().collect();

let result = &a | &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2, 3, 4, 5]);

type Output = SGSet<T>

The resulting type after applying the | operator.

impl<T: Ord + Clone> BitXor<&'_ SGSet<T>> for &SGSet<T>

fn bitxor(self, rhs: &SGSet<T>) -> SGSet<T>

Returns the symmetric difference of self and rhs as a new SGSet<T>.

Examples

use scapegoat::SGSet;

let a: SGSet<_> = vec![1, 2, 3].into_iter().collect();
let b: SGSet<_> = vec![2, 3, 4].into_iter().collect();

let result = &a ^ &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 4]);

type Output = SGSet<T>

The resulting type after applying the ^ operator.

impl<T: Ord> Default for SGSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for SGSet<T>

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<T: Ord> Extend<T> for SGSet<T>

fn extend<TreeIter: IntoIterator<Item = T>>(&mut self, iter: TreeIter)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<T: Ord> FromIterator<T> for SGSet<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T: Ord> IntoIterator for &'a SGSet<T>

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

Creates an iterator from a value.

impl<T: Ord> IntoIterator for SGSet<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = ConsumingIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord + Clone> Sub<&'_ SGSet<T>> for &SGSet<T>

fn sub(self, rhs: &SGSet<T>) -> SGSet<T>

Returns the difference of self and rhs as a new SGSet<T>.

Examples

use scapegoat::SGSet;

let a: SGSet<_> = vec![1, 2, 3].into_iter().collect();
let b: SGSet<_> = vec![3, 4, 5].into_iter().collect();

let result = &a - &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2]);

type Output = SGSet<T>

The resulting type after applying the - operator.