Lines Matching defs:set
1583 // Benchmarks on it have a counterpart in set.rs with the same keys and no values at all.
1812 let mut set = BTreeSet::new();
1813 while set.len() < n {
1814 set.insert(rng.gen());
1816 assert_eq!(set.len(), n);
1817 set
1821 let set: BTreeSet<i32> = (-(n as i32)..=-1).collect();
1822 assert_eq!(set.len(), n);
1823 set
1827 let set: BTreeSet<i32> = (1..=(n as i32)).collect();
1828 assert_eq!(set.len(), n);
1829 set
1883 let mut set = src.clone();
1884 assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 100 / 2);
1885 assert_eq!(set.len(), 100 / 2);
1899 let mut set = src.clone();
1900 while set.pop_first().is_some() {}
1901 set
1909 let mut set = src.clone();
1910 while let Some(elt) = set.iter().copied().next() {
1911 let ok = set.remove(&elt);
1914 set
1922 let mut set = src.clone();
1924 let ok = set.remove(&i);
1927 assert_eq!(set.len(), 100 / 2);
1928 set
1954 let mut set = src.clone();
1955 assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 10_000 / 2);
1956 assert_eq!(set.len(), 10_000 / 2);
1970 let mut set = src.clone();
1971 while set.pop_first().is_some() {}
1972 set
1980 let mut set = src.clone();
1981 while let Some(elt) = set.iter().copied().next() {
1982 let ok = set.remove(&elt);
1985 set
1993 let mut set = src.clone();
1995 let ok = set.remove(&i);
1998 assert_eq!(set.len(), 10_000 / 2);
1999 set
2030 mod set;
3676 self.state.set(true);
6218 self.0.set(true);
6244 self.0.set(true);
8516 c1.v[0].set(Some(&c2));
8517 c1.v[1].set(Some(&c3));
8519 c2.v[0].set(Some(&c2));
8520 c2.v[1].set(Some(&c3));
8522 c3.v[0].set(Some(&c1));
8523 c3.v[1].set(Some(&c2));
8559 c1.refs.v[0].set(Some(&c2));
8560 c1.refs.v[1].set(Some(&c3));
8561 c2.refs.v[0].set(Some(&c2));
8562 c2.refs.v[1].set(Some(&c3));
8563 c3.refs.v[0].set(Some(&c1));
8564 c3.refs.v[1].set(Some(&c2));
10899 self.version.set(self.version.get() + 1);
10900 other.version.set(other.version.get() + 1);
10945 SILENCE_PANIC.with(|s| s.set(true));
13828 x.set(1000);
19580 //! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`.
19900 (*inner).strong.set(1);
21362 /// .collect::<Vec<_>>() // The first set of allocations happens here.
21877 self.strong_ref().set(strong + 1);
21882 self.strong_ref().set(self.strong() - 1);
21901 self.weak_ref().set(weak + 1);
21906 self.weak_ref().set(self.weak() - 1);
25703 /// .collect::<Vec<_>>() // The first set of allocations happens here.
25988 //! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set.
29484 self.flipped.set(!self.flipped.get());
29929 /// // update a key, guarding against the key possibly not being set
32183 /// A set based on a B-Tree.
32189 /// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is
32354 // iterate a small set, look up in the large set
32403 /// let mut set: BTreeSet<i32> = BTreeSet::new();
32414 /// Constructs a double-ended iterator over a sub-range of elements in the set.
32427 /// let mut set = BTreeSet::new();
32428 /// set.insert(3);
32429 /// set.insert(5);
32430 /// set.insert(8);
32431 /// for &elem in set.range((Included(&4), Included(&8))) {
32434 /// assert_eq!(Some(&5), set.range(4..).next());
32614 /// Clears the set, removing all values.
32631 /// Returns `true` if the set contains a value.
32633 /// The value may be any borrowed form of the set's value type,
32642 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32643 /// assert_eq!(set.contains(&1), true);
32644 /// assert_eq!(set.contains(&4), false);
32655 /// Returns a reference to the value in the set, if any, that is equal to the given value.
32657 /// The value may be any borrowed form of the set's value type,
32666 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32667 /// assert_eq!(set.get(&2), Some(&2));
32668 /// assert_eq!(set.get(&4), None);
32704 /// Returns `true` if the set is a subset of another,
32713 /// let mut set = BTreeSet::new();
32715 /// assert_eq!(set.is_subset(&sup), true);
32716 /// set.insert(2);
32717 /// assert_eq!(set.is_subset(&sup), true);
32718 /// set.insert(4);
32719 /// assert_eq!(set.is_subset(&sup), false);
32780 /// Returns `true` if the set is a superset of another,
32789 /// let mut set = BTreeSet::new();
32791 /// assert_eq!(set.is_superset(&sub), false);
32793 /// set.insert(0);
32794 /// set.insert(1);
32795 /// assert_eq!(set.is_superset(&sub), false);
32797 /// set.insert(2);
32798 /// assert_eq!(set.is_superset(&sub), true);
32808 /// Returns a reference to the first value in the set, if any.
32809 /// This value is always the minimum of all values in the set.
32819 /// let mut set = BTreeSet::new();
32820 /// assert_eq!(set.first(), None);
32821 /// set.insert(1);
32822 /// assert_eq!(set.first(), Some(&1));
32823 /// set.insert(2);
32824 /// assert_eq!(set.first(), Some(&1));
32834 /// Returns a reference to the last value in the set, if any.
32835 /// This value is always the maximum of all values in the set.
32845 /// let mut set = BTreeSet::new();
32846 /// assert_eq!(set.last(), None);
32847 /// set.insert(1);
32848 /// assert_eq!(set.last(), Some(&1));
32849 /// set.insert(2);
32850 /// assert_eq!(set.last(), Some(&2));
32860 /// Removes the first value from the set and returns it, if any.
32861 /// The first value is always the minimum value in the set.
32869 /// let mut set = BTreeSet::new();
32871 /// set.insert(1);
32872 /// while let Some(n) = set.pop_first() {
32875 /// assert!(set.is_empty());
32885 /// Removes the last value from the set and returns it, if any.
32886 /// The last value is always the maximum value in the set.
32894 /// let mut set = BTreeSet::new();
32896 /// set.insert(1);
32897 /// while let Some(n) = set.pop_last() {
32900 /// assert!(set.is_empty());
32910 /// Adds a value to the set.
32912 /// If the set did not have this value present, `true` is returned.
32914 /// If the set did have this value present, `false` is returned, and the
32924 /// let mut set = BTreeSet::new();
32926 /// assert_eq!(set.insert(2), true);
32927 /// assert_eq!(set.insert(2), false);
32928 /// assert_eq!(set.len(), 1);
32938 /// Adds a value to the set, replacing the existing value, if any, that is equal to the given
32946 /// let mut set = BTreeSet::new();
32947 /// set.insert(Vec::<i32>::new());
32949 /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 0);
32950 /// set.replace(Vec::with_capacity(10));
32951 /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
32961 /// Removes a value from the set. Returns whether the value was
32962 /// present in the set.
32964 /// The value may be any borrowed form of the set's value type,
32973 /// let mut set = BTreeSet::new();
32975 /// set.insert(2);
32976 /// assert_eq!(set.remove(&2), true);
32977 /// assert_eq!(set.remove(&2), false);
32989 /// Removes and returns the value in the set, if any, that is equal to the given one.
32991 /// The value may be any borrowed form of the set's value type,
33000 /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
33001 /// assert_eq!(set.take(&2), Some(2));
33002 /// assert_eq!(set.take(&2), None);
33023 /// let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
33025 /// set.retain(|&k| k % 2 == 0);
33026 /// assert!(set.iter().eq([2, 4, 6].iter()));
33125 /// Splitting a set into even and odd values, reusing the original set:
33131 /// let mut set: BTreeSet<i32> = (0..8).collect();
33132 /// let evens: BTreeSet<_> = set.drain_filter(|v| v % 2 == 0).collect();
33133 /// let odds = set;
33153 /// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
33154 /// let mut set_iter = set.iter();
33166 /// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
33167 /// let mut set_iter = set.iter();
33178 /// Returns the number of elements in the set.
33197 /// Returns `true` if the set contains no elements.
33219 let mut set = BTreeSet::new();
33220 set.extend(iter);
33221 set
33237 /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
33239 /// let v: Vec<_> = set.into_iter().collect();
33644 // No checked_add, because even if a and b refer to the same set,
34273 pub mod set;
34617 let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
34618 set.retain(|&k| k % 2 == 0);
34619 assert_eq!(set.len(), 3);
34620 assert!(set.contains(&2));
34621 assert!(set.contains(&4));
34622 assert!(set.contains(&6));
34641 let mut set = BTreeSet::new();
34642 set.insert(a.spawn(Panic::Never));
34643 set.insert(b.spawn(Panic::InDrop));
34644 set.insert(c.spawn(Panic::Never));
34646 catch_unwind(move || drop(set.drain_filter(|dummy| dummy.query(true)))).ok();
34661 let mut set = BTreeSet::new();
34662 set.insert(a.spawn(Panic::Never));
34663 set.insert(b.spawn(Panic::InQuery));
34664 set.insert(c.spawn(Panic::InQuery));
34666 catch_unwind(AssertUnwindSafe(|| drop(set.drain_filter(|dummy| dummy.query(true))))).ok();
34674 assert_eq!(set.len(), 2);
34675 assert_eq!(set.first().unwrap().id(), 1);
34676 assert_eq!(set.last().unwrap().id(), 2);
34712 let set: BTreeSet<_> = xs.iter().cloned().collect();
34715 assert!(set.contains(x));
34721 let mut set = BTreeSet::new();
34724 set.insert(1);
34725 set.insert(2);
34727 let set_str = format!("{:?}", set);
34810 fn set<'new>(v: BTreeSet<&'static str>) -> BTreeSet<&'new str> {
34827 fn set<T: Sync>(v: &BTreeSet<T>) -> impl Sync + '_ {
34866 fn set<T: Send>(v: BTreeSet<T>) -> impl Send {
34905 fn set<K>(mut set: BTreeSet<K>) {
34906 set.is_empty();
34907 set.len();
34908 set.clear();
34909 set.iter();
34910 set.into_iter();
34913 fn set_debug<K: Debug>(set: BTreeSet<K>) {
34914 format!("{:?}", set);
34915 format!("{:?}", set.iter());
34916 format!("{:?}", set.into_iter());
34919 fn set_clone<K: Clone>(mut set: BTreeSet<K>) {
34920 set.clone_from(&set.clone());
34993 let mut set = BTreeSet::from_iter(data.clone());
34994 let right = set.split_off(&(data.iter().max().unwrap() + 1));
34997 assert!(set.into_iter().eq(data));
35005 let mut set = BTreeSet::from_iter(data.clone());
35006 let right = set.split_off(data.iter().min().unwrap());
35009 assert!(set.into_iter().eq(None));
35020 let mut set = BTreeSet::from_iter(data.clone());
35022 let right = set.split_off(&key);
35024 assert!(set.into_iter().eq(data.clone().into_iter().filter(|x| *x < key)));
38032 /// initialized and valid edge. This function does not set up
39920 //! A set based on a B-Tree.
39922 pub use super::btree::set::*;
43075 // set of calls to its methods.
44095 // for the exact same set of calls to its methods.
47935 /// // Initialize elements via raw pointer writes, then set length.
48554 // set self.vec length's to start, to be safe in case Drain is leaked
49024 // len set by scope guard
51896 self.fuel.set(self.fuel.get() - size);
52031 fn set(&mut self, value: u32);
52041 fn set(&mut self, value: u32) {
52050 (*p).set(19);