Struct Set

pub struct Set<T: Eq + Hash = Key> { /* private fields */ }

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

Implementations

impl<T: Eq + Hash> Set<T>

pub fn new() -> Self

Creates an empty Set.

Example

use json_api::value::{Key, Set};
let mut set = Set::<Key>::new();

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty Set, with specified capacity.

Example

let mut set = Set::with_capacity(2);

set.insert("x");
set.insert("y");

// The next insert will likely require reallocation...
set.insert("z");

pub fn capacity(&self) -> usize

Returns the number of elements the set can hold without reallocating.

Example

let set = Set::<Key>::with_capacity(2);
assert!(set.capacity() >= 2);

pub fn clear(&mut self)

Clears the set, removing all elements. Keeps the allocated memory for reuse.

Example

let mut set = Set::new();

set.insert("x");
set.clear();
assert!(set.is_empty());

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

where Q: Equivalent<T> + Hash + ?Sized,

Returns true if the set contains the specified value.

Example

let mut set = Set::new();

set.insert(1);
assert!(set.contains(&1));
assert!(!set.contains(&2));

pub fn drain(&mut self, range: RangeFull) -> Drain<'_, T>

Clears the set, returning all elements in an iterator. Keeps the allocated memory for reuse.

Example

let mut set = Set::new();

set.insert(1);
set.insert(2);

for item in set.drain(..) {
    assert!(item == 1 || item == 2);
}

assert!(set.is_empty());

pub fn insert(&mut self, key: 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.

Example

let mut set = Set::new();

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

pub fn is_empty(&self) -> bool

Returns true if the set does not contain any elements.

Example

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

set.insert("x");
assert!(!set.is_empty());

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

Return an iterator visiting all the elements of the set in the order in which they were inserted.

Example

let mut set = Set::new();

set.insert("a");
set.insert("b");
set.insert("c");

let mut iter = set.iter();

assert_eq!(iter.next(), Some(&"a"));
assert_eq!(iter.next(), Some(&"b"));
assert_eq!(iter.next(), Some(&"c"));
assert_eq!(iter.next(), None);

pub fn len(&self) -> usize

Return the number of elements in the set.

Example

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

set.insert("x");
assert_eq!(set.len(), 1);

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

where Q: Equivalent<T> + Hash + ?Sized,

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

Example

let mut set = Set::new();

set.insert("x");

assert!(set.remove("x"));
assert!(!set.remove("x"));
assert_eq!(set.len(), 0);

pub 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.

Note

This method has yet to be fully implemented in the ordermap crate.

Example

let mut set = Set::<String>::new();
set.reserve(10);

Trait Implementations

impl<T: Clone + Eq + Hash> Clone for Set<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Eq + Hash> Debug for Set<T>

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

Formats the value using the given formatter.

impl<T: Eq + Hash> Default for Set<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Set<T>

where T: Deserialize<'de> + Eq + Hash + 'de,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq + Hash> Extend<T> for Set<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

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: Eq + Hash> FromIterator<T> for Set<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T, E> FromStr for Set<T>

where T: Eq + FromStr<Err = E> + Hash, E: Into<Error>,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'a, T: Eq + Hash> IntoIterator for &'a Set<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: Eq + Hash> IntoIterator for Set<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<Set<T> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq + Eq + Hash> PartialEq for Set<T>

fn eq(&self, other: &Set<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Hash + Serialize> Serialize for Set<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq + Hash + Stringify> Stringify for Set<T>

fn to_bytes(&self) -> Vec<u8>

Returns the string representation of the give value as a byte vector.

fn stringify(&self) -> String

Returns the string representation of the given value.

impl<T: Eq + Eq + Hash> Eq for Set<T>

impl<T: Eq + Hash> StructuralPartialEq for Set<T>