Lines Matching defs:BTreeSet
1805 use std::collections::BTreeSet;
1810 fn random(n: usize) -> BTreeSet<usize> {
1812 let mut set = BTreeSet::new();
1820 fn neg(n: usize) -> BTreeSet<i32> {
1821 let set: BTreeSet<i32> = (-(n as i32)..=-1).collect();
1826 fn pos(n: usize) -> BTreeSet<i32> {
1827 let set: BTreeSet<i32> = (1..=(n as i32)).collect();
1832 fn stagger(n1: usize, factor: usize) -> [BTreeSet<u32>; 2] {
1834 let mut sets = [BTreeSet::new(), BTreeSet::new()];
1857 fn slim_set(n: usize) -> BTreeSet<usize> {
1858 (0..n).collect::<BTreeSet<_>>()
5596 use std::collections::BTreeSet;
5602 let mut x = BTreeSet::new();
5603 let mut y = BTreeSet::new();
31415 /// of the predicate, thus also serving for BTreeSet::DrainFilter.
32202 /// use std::collections::BTreeSet;
32205 /// // would be `BTreeSet<&str>` in this example).
32206 /// let mut books = BTreeSet::new();
32230 #[cfg_attr(not(test), rustc_diagnostic_item = "BTreeSet")]
32231 pub struct BTreeSet<T> {
32236 impl<T: Clone> Clone for BTreeSet<T> {
32238 BTreeSet { map: self.map.clone() }
32246 /// An iterator over the items of a `BTreeSet`.
32248 /// This `struct` is created by the [`iter`] method on [`BTreeSet`].
32251 /// [`iter`]: BTreeSet::iter
32264 /// An owning iterator over the items of a `BTreeSet`.
32266 /// This `struct` is created by the [`into_iter`] method on [`BTreeSet`]
32269 /// [`into_iter`]: BTreeSet#method.into_iter
32276 /// An iterator over a sub-range of items in a `BTreeSet`.
32278 /// This `struct` is created by the [`range`] method on [`BTreeSet`].
32281 /// [`range`]: BTreeSet::range
32288 /// A lazy iterator producing elements in the difference of `BTreeSet`s.
32290 /// This `struct` is created by the [`difference`] method on [`BTreeSet`].
32293 /// [`difference`]: BTreeSet::difference
32308 other_set: &'a BTreeSet<T>,
32320 /// A lazy iterator producing elements in the symmetric difference of `BTreeSet`s.
32323 /// [`BTreeSet`]. See its documentation for more.
32325 /// [`symmetric_difference`]: BTreeSet::symmetric_difference
32336 /// A lazy iterator producing elements in the intersection of `BTreeSet`s.
32338 /// This `struct` is created by the [`intersection`] method on [`BTreeSet`].
32341 /// [`intersection`]: BTreeSet::intersection
32356 large_set: &'a BTreeSet<T>,
32368 /// A lazy iterator producing elements in the union of `BTreeSet`s.
32370 /// This `struct` is created by the [`union`] method on [`BTreeSet`].
32373 /// [`union`]: BTreeSet::union
32392 impl<T> BTreeSet<T> {
32393 /// Makes a new, empty `BTreeSet`.
32401 /// use std::collections::BTreeSet;
32403 /// let mut set: BTreeSet<i32> = BTreeSet::new();
32407 pub const fn new() -> BTreeSet<T>
32411 BTreeSet { map: BTreeMap::new() }
32424 /// use std::collections::BTreeSet;
32427 /// let mut set = BTreeSet::new();
32453 /// use std::collections::BTreeSet;
32455 /// let mut a = BTreeSet::new();
32459 /// let mut b = BTreeSet::new();
32467 pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T>
32514 /// use std::collections::BTreeSet;
32516 /// let mut a = BTreeSet::new();
32520 /// let mut b = BTreeSet::new();
32528 pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T>
32542 /// use std::collections::BTreeSet;
32544 /// let mut a = BTreeSet::new();
32548 /// let mut b = BTreeSet::new();
32556 pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T>
32595 /// use std::collections::BTreeSet;
32597 /// let mut a = BTreeSet::new();
32600 /// let mut b = BTreeSet::new();
32607 pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T>
32619 /// use std::collections::BTreeSet;
32621 /// let mut v = BTreeSet::new();
32640 /// use std::collections::BTreeSet;
32642 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32664 /// use std::collections::BTreeSet;
32666 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32685 /// use std::collections::BTreeSet;
32687 /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32688 /// let mut b = BTreeSet::new();
32697 pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool
32710 /// use std::collections::BTreeSet;
32712 /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32713 /// let mut set = BTreeSet::new();
32722 pub fn is_subset(&self, other: &BTreeSet<T>) -> bool
32786 /// use std::collections::BTreeSet;
32788 /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
32789 /// let mut set = BTreeSet::new();
32801 pub fn is_superset(&self, other: &BTreeSet<T>) -> bool
32817 /// use std::collections::BTreeSet;
32819 /// let mut set = BTreeSet::new();
32843 /// use std::collections::BTreeSet;
32845 /// let mut set = BTreeSet::new();
32867 /// use std::collections::BTreeSet;
32869 /// let mut set = BTreeSet::new();
32892 /// use std::collections::BTreeSet;
32894 /// let mut set = BTreeSet::new();
32922 /// use std::collections::BTreeSet;
32924 /// let mut set = BTreeSet::new();
32944 /// use std::collections::BTreeSet;
32946 /// let mut set = BTreeSet::new();
32971 /// use std::collections::BTreeSet;
32973 /// let mut set = BTreeSet::new();
32998 /// use std::collections::BTreeSet;
33000 /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
33020 /// use std::collections::BTreeSet;
33023 /// let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
33042 /// use std::collections::BTreeSet;
33044 /// let mut a = BTreeSet::new();
33049 /// let mut b = BTreeSet::new();
33081 /// use std::collections::BTreeSet;
33083 /// let mut a = BTreeSet::new();
33107 BTreeSet { map: self.map.split_off(key) }
33129 /// use std::collections::BTreeSet;
33131 /// let mut set: BTreeSet<i32> = (0..8).collect();
33132 /// let evens: BTreeSet<_> = set.drain_filter(|v| v % 2 == 0).collect();
33146 /// Gets an iterator that visits the values in the `BTreeSet` in ascending order.
33151 /// use std::collections::BTreeSet;
33153 /// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
33164 /// use std::collections::BTreeSet;
33166 /// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
33183 /// use std::collections::BTreeSet;
33185 /// let mut v = BTreeSet::new();
33202 /// use std::collections::BTreeSet;
33204 /// let mut v = BTreeSet::new();
33217 impl<T: Ord> FromIterator<T> for BTreeSet<T> {
33218 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T> {
33219 let mut set = BTreeSet::new();
33226 impl<T> IntoIterator for BTreeSet<T> {
33230 /// Gets an iterator for moving out the `BTreeSet`'s contents.
33235 /// use std::collections::BTreeSet;
33237 /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
33248 impl<'a, T> IntoIterator for &'a BTreeSet<T> {
33257 /// An iterator produced by calling `drain_filter` on BTreeSet.
33311 impl<T: Ord> Extend<T> for BTreeSet<T> {
33326 impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet<T> {
33338 impl<T: Ord> Default for BTreeSet<T> {
33339 /// Creates an empty `BTreeSet`.
33340 fn default() -> BTreeSet<T> {
33341 BTreeSet::new()
33346 impl<T: Ord + Clone> Sub<&BTreeSet<T>> for &BTreeSet<T> {
33347 type Output = BTreeSet<T>;
33349 /// Returns the difference of `self` and `rhs` as a new `BTreeSet<T>`.
33354 /// use std::collections::BTreeSet;
33356 /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
33357 /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
33363 fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
33369 impl<T: Ord + Clone> BitXor<&BTreeSet<T>> for &BTreeSet<T> {
33370 type Output = BTreeSet<T>;
33372 /// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet<T>`.
33377 /// use std::collections::BTreeSet;
33379 /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
33380 /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
33386 fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
33392 impl<T: Ord + Clone> BitAnd<&BTreeSet<T>> for &BTreeSet<T> {
33393 type Output = BTreeSet<T>;
33395 /// Returns the intersection of `self` and `rhs` as a new `BTreeSet<T>`.
33400 /// use std::collections::BTreeSet;
33402 /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
33403 /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
33409 fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
33415 impl<T: Ord + Clone> BitOr<&BTreeSet<T>> for &BTreeSet<T> {
33416 type Output = BTreeSet<T>;
33418 /// Returns the union of `self` and `rhs` as a new `BTreeSet<T>`.
33423 /// use std::collections::BTreeSet;
33425 /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
33426 /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
33432 fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
33438 impl<T: Debug> Debug for BTreeSet<T> {
34297 let mut m = BTreeSet::new();
34307 const SET: &'static BTreeSet<()> = &BTreeSet::new();
34314 let mut a = BTreeSet::new();
34319 assert_eq!(a.difference(&BTreeSet::new()).min(), None);
34320 assert_eq!(a.difference(&BTreeSet::new()).max(), None);
34323 assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), None);
34324 assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), None);
34333 assert_eq!(a.difference(&BTreeSet::new()).min(), Some(&1));
34334 assert_eq!(a.difference(&BTreeSet::new()).max(), Some(&2));
34337 assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), Some(&1));
34338 assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), Some(&2));
34345 F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, &mut dyn FnMut(&i32) -> bool) -> bool,
34347 let mut set_a = BTreeSet::new();
34348 let mut set_b = BTreeSet::new();
34402 let x: BTreeSet<i32> = [3, 4].iter().copied().collect();
34403 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34454 let s246: BTreeSet<i32> = [2, 4, 6].iter().copied().collect();
34455 let s23456: BTreeSet<i32> = (2..=6).collect();
34460 let s12345: BTreeSet<i32> = (1..=5).collect();
34467 let s34567: BTreeSet<i32> = (3..=7).collect();
34474 let s1: BTreeSet<i32> = (-9..=1).collect();
34478 let s2: BTreeSet<i32> = (-9..=2).collect();
34484 let s23: BTreeSet<i32> = (2..=3).collect();
34490 let s4: BTreeSet<i32> = (4..=4).collect();
34499 let s56: BTreeSet<i32> = (5..=6).collect();
34505 let s6: BTreeSet<i32> = (6..=19).collect();
34511 let s7: BTreeSet<i32> = (7..=19).collect();
34530 let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
34531 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34558 let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
34559 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34571 let one = [1].iter().collect::<BTreeSet<_>>();
34572 let two = [2].iter().collect::<BTreeSet<_>>();
34580 let set_a = a.iter().collect::<BTreeSet<_>>();
34581 let set_b = b.iter().collect::<BTreeSet<_>>();
34617 let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
34627 let mut x: BTreeSet<_> = [1].iter().copied().collect();
34628 let mut y: BTreeSet<_> = [1].iter().copied().collect();
34641 let mut set = BTreeSet::new();
34661 let mut set = BTreeSet::new();
34681 let mut x = BTreeSet::new();
34690 let mut x = BTreeSet::new();
34695 let mut y = BTreeSet::new();
34712 let set: BTreeSet<_> = xs.iter().cloned().collect();
34721 let mut set = BTreeSet::new();
34722 let empty = BTreeSet::<i32>::new();
34735 let mut a = BTreeSet::new();
34746 let mut b = BTreeSet::new();
34786 let mut s = BTreeSet::new();
34810 fn set<'new>(v: BTreeSet<&'static str>) -> BTreeSet<&'new str> {
34827 fn set<T: Sync>(v: &BTreeSet<T>) -> impl Sync + '_ {
34831 fn iter<T: Sync>(v: &BTreeSet<T>) -> impl Sync + '_ {
34835 fn into_iter<T: Sync>(v: BTreeSet<T>) -> impl Sync {
34839 fn range<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
34843 fn drain_filter<T: Sync + Ord>(v: &mut BTreeSet<T>) -> impl Sync + '_ {
34847 fn difference<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
34851 fn intersection<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
34855 fn symmetric_difference<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
34859 fn union<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
34866 fn set<T: Send>(v: BTreeSet<T>) -> impl Send {
34870 fn iter<T: Send + Sync>(v: &BTreeSet<T>) -> impl Send + '_ {
34874 fn into_iter<T: Send>(v: BTreeSet<T>) -> impl Send {
34878 fn range<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {
34882 fn drain_filter<T: Send + Ord>(v: &mut BTreeSet<T>) -> impl Send + '_ {
34886 fn difference<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {
34890 fn intersection<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {
34894 fn symmetric_difference<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {
34898 fn union<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {
34905 fn set<K>(mut set: BTreeSet<K>) {
34913 fn set_debug<K: Debug>(set: BTreeSet<K>) {
34919 fn set_clone<K: Clone>(mut set: BTreeSet<K>) {
34926 let mut a = BTreeSet::new();
34931 let mut b = BTreeSet::new();
34950 let mut a = BTreeSet::new();
34993 let mut set = BTreeSet::from_iter(data.clone());
35005 let mut set = BTreeSet::from_iter(data.clone());
35020 let mut set = BTreeSet::from_iter(data.clone());
39935 pub use btree_set::BTreeSet;