Struct ordermap::set::OrderSet
[−]
[src]
pub struct OrderSet<T, S = RandomState> { /* fields omitted */ }
: the crate ordermap has been renamed with no change in functionality to indexmap; please update your dependencies
A hash set where the iteration order of the values is independent of their hash values.
The interface is closely compatible with the standard HashSet
, but also
has additional features.
Order
The values have a consistent order that is determined by the sequence of insertion and removal calls on the set. The order does not depend on the values or the hash function at all. Note that insertion order and value are not affected if a re-insertion is attempted once an element is already present.
All iterators traverse the set in order. Set operation iterators like
union
produce a concatenated order, as do their matching "bitwise"
operators. See their documentation for specifics.
The insertion order is preserved, with notable exceptions like the
.remove()
or .swap_remove()
methods. Methods such as .sort_by()
of
course result in a new order, depending on the sorting order.
Indices
The values are indexed in a compact range without holes in the range
0..self.len()
. For example, the method .get_full
looks up the index for
a value, and the method .get_index
looks up the value by index.
Examples
use ordermap::OrderSet; // Collects which letters appear in a sentence. let letters: OrderSet<_> = "a short treatise on fungi".chars().collect(); assert!(letters.contains(&'s')); assert!(letters.contains(&'t')); assert!(letters.contains(&'u')); assert!(!letters.contains(&'y'));
Methods
impl<T> OrderSet<T>
[src]
fn new() -> Self
[src]
Create a new set. (Does not allocate.)
fn with_capacity(n: usize) -> Self
[src]
Create a new set with capacity for n
elements.
(Does not allocate if n
is zero.)
Computes in O(n) time.
impl<T, S> OrderSet<T, S>
[src]
fn with_capacity_and_hasher(n: usize, hash_builder: S) -> Self where
S: BuildHasher,
[src]
S: BuildHasher,
Create a new set with capacity for n
elements.
(Does not allocate if n
is zero.)
Computes in O(n) time.
fn len(&self) -> usize
[src]
Return the number of elements in the set.
Computes in O(1) time.
fn is_empty(&self) -> bool
[src]
Returns true if the set contains no elements.
Computes in O(1) time.
fn with_hasher(hash_builder: S) -> Self where
S: BuildHasher,
[src]
S: BuildHasher,
Create a new set with hash_builder
fn hasher(&self) -> &S where
S: BuildHasher,
[src]
S: BuildHasher,
Return a reference to the set's BuildHasher
.
fn capacity(&self) -> usize
[src]
Computes in O(1) time.
impl<T, S> OrderSet<T, S> where
T: Hash + Eq,
S: BuildHasher,
[src]
T: Hash + Eq,
S: BuildHasher,
fn clear(&mut self)
[src]
Remove all elements in the set, while preserving its capacity.
Computes in O(n) time.
fn reserve(&mut self, additional: usize)
[src]
FIXME Not implemented fully yet
fn insert(&mut self, value: T) -> bool
[src]
Insert the value into the set.
If an equivalent item already exists in the set, it returns
false
leaving the original value in the set and without
altering its insertion order. Otherwise, it inserts the new
item and returns true
.
Computes in O(1) time (amortized average).
fn iter(&self) -> Iter<T>
[src]
Return an iterator over the values of the set, in their order
fn difference<'a, S2>(
&'a self,
other: &'a OrderSet<T, S2>
) -> Difference<'a, T, S2> where
S2: BuildHasher,
[src]
&'a self,
other: &'a OrderSet<T, S2>
) -> Difference<'a, T, S2> where
S2: BuildHasher,
Return an iterator over the values that are in self
but not other
.
Values are produced in the same order that they appear in self
.
fn symmetric_difference<'a, S2>(
&'a self,
other: &'a OrderSet<T, S2>
) -> SymmetricDifference<'a, T, S, S2> where
S2: BuildHasher,
[src]
&'a self,
other: &'a OrderSet<T, S2>
) -> SymmetricDifference<'a, T, S, S2> where
S2: BuildHasher,
Return an iterator over the values that are in self
or other
,
but not in both.
Values from self
are produced in their original order, followed by
values from other
in their original order.
fn intersection<'a, S2>(
&'a self,
other: &'a OrderSet<T, S2>
) -> Intersection<'a, T, S2> where
S2: BuildHasher,
[src]
&'a self,
other: &'a OrderSet<T, S2>
) -> Intersection<'a, T, S2> where
S2: BuildHasher,
Return an iterator over the values that are in both self
and other
.
Values are produced in the same order that they appear in self
.
fn union<'a, S2>(&'a self, other: &'a OrderSet<T, S2>) -> Union<'a, T, S> where
S2: BuildHasher,
[src]
S2: BuildHasher,
Return an iterator over all values that are in self
or other
.
Values from self
are produced in their original order, followed by
values that are unique to other
in their original order.
fn contains<Q: ?Sized>(&self, value: &Q) -> bool where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Return true
if an equivalent to value
exists in the set.
Computes in O(1) time (average).
fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T> where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Return a reference to the value stored in the set, if it is present,
else None
.
Computes in O(1) time (average).
fn get_full<Q: ?Sized>(&self, value: &Q) -> Option<(usize, &T)> where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Return item index and value
fn replace(&mut self, value: T) -> Option<T>
[src]
Adds a value to the set, replacing the existing value, if any, that is equal to the given one. Returns the replaced value.
Computes in O(1) time (average).
fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
FIXME Same as .swap_remove
Computes in O(1) time (average).
fn swap_remove<Q: ?Sized>(&mut self, value: &Q) -> bool where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Remove the value from the set, and return true
if it was present.
Like Vec::swap_remove
, the value is removed by swapping it with the
last element of the set and popping it off. This perturbs
the postion of what used to be the last element!
Return false
if value
was not in the set.
Computes in O(1) time (average).
fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
FIXME Same as .swap_take
Computes in O(1) time (average).
fn swap_take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Removes and returns the value in the set, if any, that is equal to the given one.
Like Vec::swap_remove
, the value is removed by swapping it with the
last element of the set and popping it off. This perturbs
the postion of what used to be the last element!
Return None
if value
was not in the set.
Computes in O(1) time (average).
fn swap_remove_full<Q: ?Sized>(&mut self, value: &Q) -> Option<(usize, T)> where
Q: Hash + Equivalent<T>,
[src]
Q: Hash + Equivalent<T>,
Remove the value from the set return it and the index it had.
Like Vec::swap_remove
, the value is removed by swapping it with the
last element of the set and popping it off. This perturbs
the postion of what used to be the last element!
Return None
if value
was not in the set.
fn pop(&mut self) -> Option<T>
[src]
Remove the last value
Computes in O(1) time (average).
fn retain<F>(&mut self, keep: F) where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Scan through each value in the set and keep those where the
closure keep
returns true
.
The elements are visited in order, and remaining elements keep their order.
Computes in O(n) time (average).
fn sort(&mut self) where
T: Ord,
[src]
T: Ord,
Sort the set’s values by their default ordering.
See sort_by
for details.
fn sort_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
[src]
F: FnMut(&T, &T) -> Ordering,
Sort the set’s values in place using the comparison function compare
.
Computes in O(n log n) time and O(n) space. The sort is stable.
fn sorted_by<F>(self, cmp: F) -> IntoIter<T> where
F: FnMut(&T, &T) -> Ordering,
[src]
F: FnMut(&T, &T) -> Ordering,
Sort the values of the set and return a by value iterator of the values with the result.
The sort is stable.
fn drain(&mut self, range: RangeFull) -> Drain<T>
[src]
Clears the OrderSet
, returning all values as a drain iterator.
Keeps the allocated memory for reuse.
impl<T, S> OrderSet<T, S>
[src]
fn get_index(&self, index: usize) -> Option<&T>
[src]
Get a value by index
Valid indices are 0 <= index < self.len()
Computes in O(1) time.
fn swap_remove_index(&mut self, index: usize) -> Option<T>
[src]
Remove the key-value pair by index
Valid indices are 0 <= index < self.len()
Computes in O(1) time (average).
impl<T, S> OrderSet<T, S> where
T: Eq + Hash,
S: BuildHasher,
[src]
T: Eq + Hash,
S: BuildHasher,
fn is_disjoint<S2>(&self, other: &OrderSet<T, S2>) -> bool where
S2: BuildHasher,
[src]
S2: BuildHasher,
Returns true
if self
has no elements in common with other
.
fn is_subset<S2>(&self, other: &OrderSet<T, S2>) -> bool where
S2: BuildHasher,
[src]
S2: BuildHasher,
Returns true
if all elements of self
are contained in other
.
fn is_superset<S2>(&self, other: &OrderSet<T, S2>) -> bool where
S2: BuildHasher,
[src]
S2: BuildHasher,
Returns true
if all elements of other
are contained in self
.
Trait Implementations
impl<T, S> Serialize for OrderSet<T, S> where
T: Serialize + Hash + Eq,
S: BuildHasher,
[src]
T: Serialize + Hash + Eq,
S: BuildHasher,
Requires crate feature "serde-1"
fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error> where
Se: Serializer,
[src]
Se: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'de, T, S> Deserialize<'de> for OrderSet<T, S> where
T: Deserialize<'de> + Eq + Hash,
S: Default + BuildHasher,
[src]
T: Deserialize<'de> + Eq + Hash,
S: Default + BuildHasher,
Requires crate feature "serde-1"
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl<T: Clone, S: Clone> Clone for OrderSet<T, S>
[src]
fn clone(&self) -> OrderSet<T, S>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<T, S> Debug for OrderSet<T, S> where
T: Debug + Hash + Eq,
S: BuildHasher,
[src]
T: Debug + Hash + Eq,
S: BuildHasher,
impl<'a, T, S> IntoIterator for &'a OrderSet<T, S> where
T: Hash + Eq,
S: BuildHasher,
[src]
T: Hash + Eq,
S: BuildHasher,
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, S> IntoIterator for OrderSet<T, S> where
T: Hash + Eq,
S: BuildHasher,
[src]
T: Hash + Eq,
S: BuildHasher,
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) -> Self::IntoIter
[src]
Creates an iterator from a value. Read more
impl<T, S> FromIterator<T> for OrderSet<T, S> where
T: Hash + Eq,
S: BuildHasher + Default,
[src]
T: Hash + Eq,
S: BuildHasher + Default,
fn from_iter<I: IntoIterator<Item = T>>(iterable: I) -> Self
[src]
Creates a value from an iterator. Read more
impl<T, S> Extend<T> for OrderSet<T, S> where
T: Hash + Eq,
S: BuildHasher,
[src]
T: Hash + Eq,
S: BuildHasher,
fn extend<I: IntoIterator<Item = T>>(&mut self, iterable: I)
[src]
Extends a collection with the contents of an iterator. Read more
impl<'a, T, S> Extend<&'a T> for OrderSet<T, S> where
T: Hash + Eq + Copy,
S: BuildHasher,
[src]
T: Hash + Eq + Copy,
S: BuildHasher,
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iterable: I)
[src]
Extends a collection with the contents of an iterator. Read more
impl<T, S> Default for OrderSet<T, S> where
S: BuildHasher + Default,
[src]
S: BuildHasher + Default,
impl<T, S1, S2> PartialEq<OrderSet<T, S2>> for OrderSet<T, S1> where
T: Hash + Eq,
S1: BuildHasher,
S2: BuildHasher,
[src]
T: Hash + Eq,
S1: BuildHasher,
S2: BuildHasher,
fn eq(&self, other: &OrderSet<T, S2>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<T, S> Eq for OrderSet<T, S> where
T: Eq + Hash,
S: BuildHasher,
[src]
T: Eq + Hash,
S: BuildHasher,
impl<'a, 'b, T, S1, S2> BitAnd<&'b OrderSet<T, S2>> for &'a OrderSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
[src]
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
type Output = OrderSet<T, S1>
The resulting type after applying the &
operator.
fn bitand(self, other: &'b OrderSet<T, S2>) -> Self::Output
[src]
Returns the set intersection, cloned into a new set.
Values are collected in the same order that they appear in self
.
impl<'a, 'b, T, S1, S2> BitOr<&'b OrderSet<T, S2>> for &'a OrderSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
[src]
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
type Output = OrderSet<T, S1>
The resulting type after applying the |
operator.
fn bitor(self, other: &'b OrderSet<T, S2>) -> Self::Output
[src]
Returns the set union, cloned into a new set.
Values from self
are collected in their original order, followed by
values that are unique to other
in their original order.
impl<'a, 'b, T, S1, S2> BitXor<&'b OrderSet<T, S2>> for &'a OrderSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
[src]
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
type Output = OrderSet<T, S1>
The resulting type after applying the ^
operator.
fn bitxor(self, other: &'b OrderSet<T, S2>) -> Self::Output
[src]
Returns the set symmetric-difference, cloned into a new set.
Values from self
are collected in their original order, followed by
values from other
in their original order.
impl<'a, 'b, T, S1, S2> Sub<&'b OrderSet<T, S2>> for &'a OrderSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
[src]
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,