Lines Matching defs:drain
6116 assert_eq!(s.drain(2..4).collect::<String>(), "β");
6120 t.drain(..0);
6122 t.drain(..1);
6124 t.drain(3..);
6126 t.drain(..);
6134 s.drain((Excluded(usize::MAX), Included(0)));
6141 s.drain((Included(0), Included(usize::MAX)));
7146 for i in vec.drain(..) {
7157 for i in vec.drain(..) {
7168 for i in vec.drain(..).rev() {
7179 for i in vec.drain(..) {
7190 v.drain(5..6);
7196 for _ in v.drain(4..) {}
7200 for _ in v.drain(1..4) {}
7204 for _ in v.drain(1..4).rev() {}
7208 for _ in v.drain(1..4).rev() {}
7215 for _ in v.drain(1..=3) {}
7219 for _ in v.drain(1..=5) {}
7223 for _ in v.drain(0..=5) {}
7227 for _ in v.drain(0..=3) {}
7231 for _ in v.drain(..=0) {}
7241 for _ in v.drain(usize::MAX - 1..) {}
7248 for _ in v.drain(usize::MAX - 1..=usize::MAX - 1) {}
7259 v.drain(0..=usize::MAX);
7266 v.drain(5..=5);
7273 v.drain((Excluded(usize::MAX), Included(0)));
7280 v.drain((Included(0), Included(usize::MAX)));
7313 v.drain(2..=5);
7647 fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
7876 let drain = data.drain_filter(filter);
7879 drain.for_each(drop);
7944 let drain = vec.drain_filter(|&mut x| x % 2 != 0);
7945 drop(drain);
8257 next_then_drop(v.drain(5..));
11642 let mut iter = d.drain(..);
11659 assert_eq!(d.drain(..).collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
11673 assert_eq!(d.drain(..).collect::<Vec<_>>(), [8, 7, 6, 0, 1, 2, 3, 4]);
11688 let mut it = d.drain(..);
12303 fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
12857 v.drain(1..=4);
13384 check_exact_size_iterator(heap.len(), heap.clone().drain());
13560 assert_eq!(q.drain().take(5).count(), 5);
13664 fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
17729 /// let t: String = s.drain(..beta_offset).collect();
17734 /// s.drain(..);
17737 #[stable(feature = "drain", since = "1.6.0")]
17738 pub fn drain<R>(&mut self, range: R) -> Drain<'_>
18703 /// This struct is created by the [`drain`] method on [`String`]. See its
18706 /// [`drain`]: String::drain
18707 #[stable(feature = "drain", since = "1.6.0")]
18726 #[stable(feature = "drain", since = "1.6.0")]
18728 #[stable(feature = "drain", since = "1.6.0")]
18731 #[stable(feature = "drain", since = "1.6.0")]
18735 // Use Vec::drain. "Reaffirm" the bounds checks to avoid
18739 self_vec.drain(self.start..self.end);
18753 /// let mut drain = s.drain(..);
18754 /// assert_eq!(drain.as_str(), "abc");
18755 /// let _ = drain.next().unwrap();
18756 /// assert_eq!(drain.as_str(), "bc");
18779 #[stable(feature = "drain", since = "1.6.0")]
18798 #[stable(feature = "drain", since = "1.6.0")]
31501 // the predicate decided not to drain. Making this upper bound more accurate
40119 /// This `struct` is created by the [`drain`] method on [`VecDeque`]. See its
40122 /// [`drain`]: VecDeque::drain
40123 #[stable(feature = "drain", since = "1.6.0")]
40142 #[stable(feature = "drain", since = "1.6.0")]
40144 #[stable(feature = "drain", since = "1.6.0")]
40147 #[stable(feature = "drain", since = "1.6.0")]
40208 #[stable(feature = "drain", since = "1.6.0")]
40223 #[stable(feature = "drain", since = "1.6.0")]
40231 #[stable(feature = "drain", since = "1.6.0")]
40384 #[stable(feature = "drain", since = "1.6.0")]
40385 pub use self::drain::Drain;
40387 mod drain;
41527 /// let drained = v.drain(2..).collect::<VecDeque<_>>();
41532 /// v.drain(..);
41536 #[stable(feature = "drain", since = "1.6.0")]
41537 pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
41564 // the drain.
41571 // "forget" about the values after the start of the drain until after
41572 // the drain is complete and the Drain destructor is run.
42391 self.extend(other.drain(..));
43816 // Check that we drain the correct values
43817 let drained: VecDeque<_> = tester.drain(drain_start..drain_end).collect();
45008 /// * `.drain_sorted()` is *O*(*n* \* log(*n*)); much slower than `.drain()`.
45347 /// for x in heap.drain() {
45354 #[stable(feature = "drain", since = "1.6.0")]
45355 pub fn drain(&mut self) -> Drain<'_, T> {
45356 Drain { iter: self.data.drain(..) }
45377 self.drain();
45622 /// This `struct` is created by [`BinaryHeap::drain()`]. See its
45625 /// [`drain`]: BinaryHeap::drain
45626 #[stable(feature = "drain", since = "1.6.0")]
45632 #[stable(feature = "drain", since = "1.6.0")]
45647 #[stable(feature = "drain", since = "1.6.0")]
45655 #[stable(feature = "drain", since = "1.6.0")]
46293 /// This `struct` is created by [`Vec::drain`].
46300 /// let iter: std::vec::Drain<_> = v.drain(..);
46302 #[stable(feature = "drain", since = "1.6.0")]
46331 /// let mut drain = vec.drain(..);
46332 /// assert_eq!(drain.as_slice(), &['a', 'b', 'c']);
46333 /// let _ = drain.next().unwrap();
46334 /// assert_eq!(drain.as_slice(), &['b', 'c']);
46356 #[stable(feature = "drain", since = "1.6.0")]
46358 #[stable(feature = "drain", since = "1.6.0")]
46361 #[stable(feature = "drain", since = "1.6.0")]
46375 #[stable(feature = "drain", since = "1.6.0")]
46383 #[stable(feature = "drain", since = "1.6.0")]
46425 #[stable(feature = "drain", since = "1.6.0")]
46892 #[stable(feature = "drain", since = "1.6.0")]
46893 pub use self::drain::Drain;
46895 mod drain;
47790 /// The [`drain`] method can emulate `truncate`, but causes the excess
47825 /// [`drain`]: Vec::drain
48527 /// let u: Vec<_> = v.drain(1..).collect();
48532 /// v.drain(..);
48535 #[stable(feature = "drain", since = "1.6.0")]
48536 pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>
49361 Splice { drain: self.drain(range), replace_with: replace_with.into_iter() }
49840 drain: &'b mut DrainFilter<'a, T, F, A>,
49849 if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
49856 let ptr = self.drain.vec.as_mut_ptr();
49857 let src = ptr.add(self.drain.idx);
49858 let dst = src.sub(self.drain.del);
49859 let tail_len = self.drain.old_len - self.drain.idx;
49862 self.drain.vec.set_len(self.drain.old_len - self.drain.del);
49867 let backshift = BackshiftOnDrop { drain: self };
49872 if !backshift.drain.panic_flag {
49873 backshift.drain.for_each(drop);
49980 pub(super) drain: Drain<'a, I::Item, A>,
49989 self.drain.next()
49993 self.drain.size_hint()
50000 self.drain.next_back()
50010 self.drain.by_ref().for_each(drop);
50013 if self.drain.tail_len == 0 {
50014 self.drain.vec.as_mut().extend(self.replace_with.by_ref());
50018 // First fill the range left by drain().
50019 if !self.drain.fill(&mut self.replace_with) {
50027 self.drain.move_tail(lower_bound);
50028 if !self.drain.fill(&mut self.replace_with) {
50038 self.drain.move_tail(collected.len());
50039 let filled = self.drain.fill(&mut collected);