Struct collections::btree_set::BTreeSet 1.0.0
[−]
[src]
pub struct BTreeSet<T> { /* fields omitted */ }
A set based on a B-Tree.
See BTreeMap
's documentation for a detailed discussion of this collection's performance
benefits and drawbacks.
It is a logic error for an item to be modified in such a way that the item's ordering relative
to any other item, as determined by the Ord
trait, changes while it is in the set. This is
normally only possible through Cell
, RefCell
, global state, I/O, or unsafe code.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; // Type inference lets us omit an explicit type signature (which // would be `BTreeSet<&str>` in this example). let mut books = BTreeSet::new(); // Add some books. books.insert("A Dance With Dragons"); books.insert("To Kill a Mockingbird"); books.insert("The Odyssey"); books.insert("The Great Gatsby"); // 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); } }use std::collections::BTreeSet; // Type inference lets us omit an explicit type signature (which // would be `BTreeSet<&str>` in this example). let mut books = BTreeSet::new(); // Add some books. books.insert("A Dance With Dragons"); books.insert("To Kill a Mockingbird"); books.insert("The Odyssey"); books.insert("The Great Gatsby"); // 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); }Run
Methods
impl<T: Ord> BTreeSet<T>
[src]
impl<T> BTreeSet<T>
[src]
fn iter(&self) -> Iter<T>
Gets an iterator over the BTreeSet's contents.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect(); for x in set.iter() { println!("{}", x); } let v: Vec<_> = set.iter().cloned().collect(); assert_eq!(v, [1, 2, 3, 4]); }use std::collections::BTreeSet; let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect(); for x in set.iter() { println!("{}", x); } let v: Vec<_> = set.iter().cloned().collect(); assert_eq!(v, [1, 2, 3, 4]);Run
impl<T: Ord> BTreeSet<T>
[src]
fn range<'a, Min: ?Sized + Ord, Max: ?Sized + Ord>(&'a self, min: Bound<&Min>, max: Bound<&Max>) -> Range<'a, T> where T: Borrow<Min> + Borrow<Max>
Constructs a double-ended iterator over a sub-range of elements in the set, starting
at min, and ending at max. If min is Unbounded
, then it will be treated as "negative
infinity", and if max is Unbounded
, then it will be treated as "positive infinity".
Thus range(Unbounded, Unbounded) will yield the whole collection.
Examples
#![feature(btree_range, collections_bound)] extern crate collections; fn main() { use std::collections::BTreeSet; use std::collections::Bound::{Included, Unbounded}; let mut set = BTreeSet::new(); set.insert(3); set.insert(5); set.insert(8); for &elem in set.range(Included(&4), Included(&8)) { println!("{}", elem); } assert_eq!(Some(&5), set.range(Included(&4), Unbounded).next()); }#![feature(btree_range, collections_bound)] use std::collections::BTreeSet; use std::collections::Bound::{Included, Unbounded}; let mut set = BTreeSet::new(); set.insert(3); set.insert(5); set.insert(8); for &elem in set.range(Included(&4), Included(&8)) { println!("{}", elem); } assert_eq!(Some(&5), set.range(Included(&4), Unbounded).next());Run
impl<T: Ord> BTreeSet<T>
[src]
fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T>
Visits the values representing the difference, in ascending order.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let diff: Vec<_> = a.difference(&b).cloned().collect(); assert_eq!(diff, [1]); }use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let diff: Vec<_> = a.difference(&b).cloned().collect(); assert_eq!(diff, [1]);Run
fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T>
Visits the values representing the symmetric difference, in ascending order.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect(); assert_eq!(sym_diff, [1, 3]); }use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect(); assert_eq!(sym_diff, [1, 3]);Run
fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T>
Visits the values representing the intersection, in ascending order.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let intersection: Vec<_> = a.intersection(&b).cloned().collect(); assert_eq!(intersection, [2]); }use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); let mut b = BTreeSet::new(); b.insert(2); b.insert(3); let intersection: Vec<_> = a.intersection(&b).cloned().collect(); assert_eq!(intersection, [2]);Run
fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T>
Visits the values representing the union, in ascending order.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); let mut b = BTreeSet::new(); b.insert(2); let union: Vec<_> = a.union(&b).cloned().collect(); assert_eq!(union, [1, 2]); }use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); let mut b = BTreeSet::new(); b.insert(2); let union: Vec<_> = a.union(&b).cloned().collect(); assert_eq!(union, [1, 2]);Run
fn len(&self) -> usize
Returns the number of elements in the set.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut v = BTreeSet::new(); assert_eq!(v.len(), 0); v.insert(1); assert_eq!(v.len(), 1); }use std::collections::BTreeSet; let mut v = BTreeSet::new(); assert_eq!(v.len(), 0); v.insert(1); assert_eq!(v.len(), 1);Run
fn is_empty(&self) -> bool
Returns true if the set contains no elements.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut v = BTreeSet::new(); assert!(v.is_empty()); v.insert(1); assert!(!v.is_empty()); }use std::collections::BTreeSet; let mut v = BTreeSet::new(); assert!(v.is_empty()); v.insert(1); assert!(!v.is_empty());Run
fn clear(&mut self)
Clears the set, removing all values.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut v = BTreeSet::new(); v.insert(1); v.clear(); assert!(v.is_empty()); }use std::collections::BTreeSet; let mut v = BTreeSet::new(); v.insert(1); v.clear(); assert!(v.is_empty());Run
fn contains<Q: ?Sized>(&self, value: &Q) -> bool where T: Borrow<Q>, Q: Ord
Returns true
if the set contains a value.
The value may be any borrowed form of the set's value type, but the ordering on the borrowed form must match the ordering on the value type.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); assert_eq!(set.contains(&1), true); assert_eq!(set.contains(&4), false); }use std::collections::BTreeSet; let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); assert_eq!(set.contains(&1), true); assert_eq!(set.contains(&4), false);Run
fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T> where T: Borrow<Q>, Q: Ord
1.9.0
Returns a reference to the value in the set, if any, that is equal to the given value.
The value may be any borrowed form of the set's value type, but the ordering on the borrowed form must match the ordering on the value type.
fn is_disjoint(&self, other: &BTreeSet<T>) -> bool
Returns true
if the set has no elements in common with other
.
This is equivalent to checking for an empty intersection.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); let mut b = BTreeSet::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); }use std::collections::BTreeSet; let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); let mut b = BTreeSet::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);Run
fn is_subset(&self, other: &BTreeSet<T>) -> bool
Returns true
if the set is a subset of another.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); let mut set = BTreeSet::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); }use std::collections::BTreeSet; let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); let mut set = BTreeSet::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);Run
fn is_superset(&self, other: &BTreeSet<T>) -> bool
Returns true
if the set is a superset of another.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let sub: BTreeSet<_> = [1, 2].iter().cloned().collect(); let mut set = BTreeSet::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); }use std::collections::BTreeSet; let sub: BTreeSet<_> = [1, 2].iter().cloned().collect(); let mut set = BTreeSet::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);Run
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 not updated. See the module-level documentation for more.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut set = BTreeSet::new(); assert_eq!(set.insert(2), true); assert_eq!(set.insert(2), false); assert_eq!(set.len(), 1); }use std::collections::BTreeSet; let mut set = BTreeSet::new(); assert_eq!(set.insert(2), true); assert_eq!(set.insert(2), false); assert_eq!(set.len(), 1);Run
fn replace(&mut self, value: T) -> Option<T>
1.9.0
Adds a value to the set, replacing the existing value, if any, that is equal to the given one. Returns the replaced value.
fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where T: Borrow<Q>, Q: Ord
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 the ordering on the borrowed form must match the ordering on the value type.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut set = BTreeSet::new(); set.insert(2); assert_eq!(set.remove(&2), true); assert_eq!(set.remove(&2), false); }use std::collections::BTreeSet; let mut set = BTreeSet::new(); set.insert(2); assert_eq!(set.remove(&2), true); assert_eq!(set.remove(&2), false);Run
fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where T: Borrow<Q>, Q: Ord
1.9.0
Removes and returns the value in the set, if any, that is equal to the given one.
The value may be any borrowed form of the set's value type, but the ordering on the borrowed form must match the ordering on the value type.
fn append(&mut self, other: &mut Self)
1.11.0
Moves all elements from other
into Self
, leaving other
empty.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); a.insert(3); let mut b = BTreeSet::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)); }use std::collections::BTreeSet; let mut a = BTreeSet::new(); a.insert(1); a.insert(2); a.insert(3); let mut b = BTreeSet::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));Run
fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self where T: Borrow<Q>
1.11.0
Splits the collection into two at the given key. Returns everything after the given key, including the key.
Examples
Basic usage:
extern crate collections; fn main() { use std::collections::BTreeMap; let mut a = BTreeMap::new(); a.insert(1, "a"); a.insert(2, "b"); a.insert(3, "c"); a.insert(17, "d"); a.insert(41, "e"); let b = a.split_off(&3); assert_eq!(a.len(), 2); assert_eq!(b.len(), 3); assert_eq!(a[&1], "a"); assert_eq!(a[&2], "b"); assert_eq!(b[&3], "c"); assert_eq!(b[&17], "d"); assert_eq!(b[&41], "e"); }use std::collections::BTreeMap; let mut a = BTreeMap::new(); a.insert(1, "a"); a.insert(2, "b"); a.insert(3, "c"); a.insert(17, "d"); a.insert(41, "e"); let b = a.split_off(&3); assert_eq!(a.len(), 2); assert_eq!(b.len(), 3); assert_eq!(a[&1], "a"); assert_eq!(a[&2], "b"); assert_eq!(b[&3], "c"); assert_eq!(b[&17], "d"); assert_eq!(b[&41], "e");Run
Trait Implementations
impl<T: Clone> Clone for BTreeSet<T>
[src]
fn clone(&self) -> BTreeSet<T>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<T: Hash> Hash for BTreeSet<T>
[src]
fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)
Feeds this value into the state given, updating the hasher as necessary.
fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0
Feeds a slice of this type into the state provided.
impl<T: PartialEq> PartialEq for BTreeSet<T>
[src]
fn eq(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests for !=
.
impl<T: Eq> Eq for BTreeSet<T>
[src]
impl<T: Ord> Ord for BTreeSet<T>
[src]
fn cmp(&self, __arg_0: &BTreeSet<T>) -> Ordering
This method returns an Ordering
between self
and other
. Read more
impl<T: PartialOrd> PartialOrd for BTreeSet<T>
[src]
fn partial_cmp(&self, __arg_0: &BTreeSet<T>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, __arg_0: &BTreeSet<T>) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<T: Ord> FromIterator<T> for BTreeSet<T>
[src]
fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> BTreeSet<T>
Creates a value from an iterator. Read more
impl<T> IntoIterator for BTreeSet<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>
Gets an iterator for moving out the BtreeSet's contents.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect(); let v: Vec<_> = set.into_iter().collect(); assert_eq!(v, [1, 2, 3, 4]); }use std::collections::BTreeSet; let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect(); let v: Vec<_> = set.into_iter().collect(); assert_eq!(v, [1, 2, 3, 4]);Run
impl<'a, T> IntoIterator for &'a BTreeSet<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: Ord> Extend<T> for BTreeSet<T>
[src]
fn extend<Iter: IntoIterator<Item=T>>(&mut self, iter: Iter)
Extends a collection with the contents of an iterator. Read more
impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet<T>
1.2.0[src]
fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I)
Extends a collection with the contents of an iterator. Read more
impl<T: Ord> Default for BTreeSet<T>
[src]
impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T>
[src]
type Output = BTreeSet<T>
The resulting type after applying the -
operator
fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T>
Returns the difference of self
and rhs
as a new BTreeSet<T>
.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]); }use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]);Run
impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T>
[src]
type Output = BTreeSet<T>
The resulting type after applying the ^
operator
fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T>
Returns the symmetric difference of self
and rhs
as a new BTreeSet<T>
.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]); }use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]);Run
impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T>
[src]
type Output = BTreeSet<T>
The resulting type after applying the &
operator
fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T>
Returns the intersection of self
and rhs
as a new BTreeSet<T>
.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]); }use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]);Run
impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T>
[src]
type Output = BTreeSet<T>
The resulting type after applying the |
operator
fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T>
Returns the union of self
and rhs
as a new BTreeSet<T>
.
Examples
extern crate collections; fn main() { use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]); }use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = 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]);Run