Lines Matching defs:deque

12870     let deque: VecDeque<_> = vec![1, 2, 3, 5, 6].into();
12871     assert!(deque.as_slices().1.is_empty());
12872     assert_eq!(deque.binary_search(&3), Ok(2));
12873     assert_eq!(deque.binary_search(&4), Err(3));
12876     let mut deque: VecDeque<_> = vec![5, 6].into();
12877     deque.push_front(3);
12878     deque.push_front(2);
12879     deque.push_front(1);
12880     deque.push_back(10);
12881     assert!(!deque.as_slices().0.is_empty());
12882     assert!(!deque.as_slices().1.is_empty());
12883     assert_eq!(deque.binary_search(&0), Err(0));
12884     assert_eq!(deque.binary_search(&1), Ok(0));
12885     assert_eq!(deque.binary_search(&5), Ok(3));
12886     assert_eq!(deque.binary_search(&7), Err(5));
12887     assert_eq!(deque.binary_search(&20), Err(6));
12892     let deque: VecDeque<_> = vec![(1,), (2,), (3,), (5,), (6,)].into();
12894     assert_eq!(deque.binary_search_by(|&(v,)| v.cmp(&3)), Ok(2));
12895     assert_eq!(deque.binary_search_by(|&(v,)| v.cmp(&4)), Err(3));
12900     let deque: VecDeque<_> = vec![(1,), (2,), (3,), (5,), (6,)].into();
12902     assert_eq!(deque.binary_search_by_key(&3, |&(v,)| v), Ok(2));
12903     assert_eq!(deque.binary_search_by_key(&4, |&(v,)| v), Err(3));
12909     let deque: VecDeque<_> = vec![1, 2, 3, 5, 6].into();
12910     assert!(deque.as_slices().1.is_empty());
12911     assert_eq!(deque.partition_point(|&v| v <= 3), 3);
12914     let mut deque: VecDeque<_> = vec![5, 6].into();
12915     deque.push_front(3);
12916     deque.push_front(2);
12917     deque.push_front(1);
12918     deque.push_back(10);
12919     assert!(!deque.as_slices().0.is_empty());
12920     assert!(!deque.as_slices().1.is_empty());
12921     assert_eq!(deque.partition_point(|&v| v <= 5), 4);
12932     // we end up with a deque of the correct size
40128     pub(crate) deque: NonNull<VecDeque<T>>,
40156                 let source_deque = unsafe { self.0.deque.as_mut() };
41512     /// Note 2: It is unspecified how many elements are removed from the deque,
41543         // When the Drain is first created, the source deque is shortened to
41553         // The deque's elements are parted into three segments:
41576             deque: NonNull::from(&mut *self),
41584                 // Hence the raw pointer we created above, for `deque`, remains valid.
42494     /// Rearranges the internal storage of this deque so it is one contiguous
42499     /// sort a deque.
42510     /// Sorting the content of a deque.
42521     /// // sorting the deque
42543     ///     // we can now be sure that `slice` contains all elements of the deque,
42730     // be less than half the length of the deque.
42779     /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
42781     /// assert_eq!(deque.binary_search(&13),  Ok(9));
42782     /// assert_eq!(deque.binary_search(&4),   Err(7));
42783     /// assert_eq!(deque.binary_search(&100), Err(13));
42784     /// let r = deque.binary_search(&1);
42795     /// let mut deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
42797     /// let idx = deque.binary_search(&num).unwrap_or_else(|x| x);
42798     /// deque.insert(idx, num);
42799     /// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
42839     /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
42841     /// assert_eq!(deque.binary_search_by(|x| x.cmp(&13)),  Ok(9));
42842     /// assert_eq!(deque.binary_search_by(|x| x.cmp(&4)),   Err(7));
42843     /// assert_eq!(deque.binary_search_by(|x| x.cmp(&100)), Err(13));
42844     /// let r = deque.binary_search_by(|x| x.cmp(&1));
42893     /// let deque: VecDeque<_> = vec![(0, 0), (2, 1), (4, 1), (5, 1),
42897     /// assert_eq!(deque.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
42898     /// assert_eq!(deque.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
42899     /// assert_eq!(deque.binary_search_by_key(&100, |&(a, b)| b), Err(13));
42900     /// let r = deque.binary_search_by_key(&1, |&(a, b)| b);
42916     /// The deque is assumed to be partitioned according to the given predicate.
42917     /// This means that all elements for which the predicate returns true are at the start of the deque
42922     /// If this deque is not partitioned, the returned result is unspecified and meaningless,
42937     /// let deque: VecDeque<_> = vec![1, 2, 3, 3, 5, 6, 7].into();
42938     /// let i = deque.partition_point(|&x| x < 5);
42941     /// assert!(deque.iter().take(i).all(|&x| x < 5));
42942     /// assert!(deque.iter().skip(i).all(|&x| !(x < 5)));
43250     /// let deque: VecDeque<_> = (1..5).collect();
43251     /// let ptr = deque.as_slices().0.as_ptr();
43252     /// let vec = Vec::from(deque);
43257     /// let mut deque: VecDeque<_> = (1..5).collect();
43258     /// deque.push_front(9);
43259     /// deque.push_front(8);
43260     /// let ptr = deque.as_slices().1.as_ptr();
43261     /// let vec = Vec::from(deque);