Lines Matching refs:BTreeSet
1805 use std::collections::BTreeSet;
1810 fn random(n: usize) -> BTreeSet<usize> { in random()
1812 let mut set = BTreeSet::new(); in random()
1820 fn neg(n: usize) -> BTreeSet<i32> { in neg()
1821 let set: BTreeSet<i32> = (-(n as i32)..=-1).collect(); in neg()
1826 fn pos(n: usize) -> BTreeSet<i32> { in pos()
1827 let set: BTreeSet<i32> = (1..=(n as i32)).collect(); in pos()
1832 fn stagger(n1: usize, factor: usize) -> [BTreeSet<u32>; 2] { in stagger()
1834 let mut sets = [BTreeSet::new(), BTreeSet::new()];
1857 fn slim_set(n: usize) -> BTreeSet<usize> { in slim_set()
1858 (0..n).collect::<BTreeSet<_>>() in slim_set()
5596 use std::collections::BTreeSet;
5602 let mut x = BTreeSet::new();
5603 let mut y = BTreeSet::new();
32231 pub struct BTreeSet<T> {
32236 impl<T: Clone> Clone for BTreeSet<T> {
32238 BTreeSet { map: self.map.clone() }
32308 other_set: &'a BTreeSet<T>,
32356 large_set: &'a BTreeSet<T>,
32392 impl<T> BTreeSet<T> { impl
32407 pub const fn new() -> BTreeSet<T>
32411 BTreeSet { map: BTreeMap::new() }
32467 pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T>
32528 pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T>
32556 pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T>
32607 pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T>
32697 pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool
32722 pub fn is_subset(&self, other: &BTreeSet<T>) -> bool
32801 pub fn is_superset(&self, other: &BTreeSet<T>) -> bool
33107 BTreeSet { map: self.map.split_off(key) }
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> {
33248 impl<'a, T> IntoIterator for &'a BTreeSet<T> {
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> {
33340 fn default() -> BTreeSet<T> {
33341 BTreeSet::new()
33346 impl<T: Ord + Clone> Sub<&BTreeSet<T>> for &BTreeSet<T> {
33347 type Output = BTreeSet<T>;
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>;
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>;
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>;
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;