Lines Matching defs:ring

2419         let ring: VecDeque<i32> = VecDeque::new();
2420 black_box(ring);
2437 let ring: VecDeque<_> = (0..1000).collect();
2441 for &i in &ring {
2450 let mut ring: VecDeque<_> = (0..1000).collect();
2454 for i in &mut ring {
2463 let ring: VecDeque<_> = (0..1000).collect();
2465 b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b))))
3205 let mut ring = LinkedList::new();
3206 ring.push_back(Elem);
3207 ring.push_front(Elem);
3208 ring.push_back(Elem);
3209 ring.push_front(Elem);
3210 drop(ring);
3227 let mut ring = LinkedList::new();
3228 ring.push_back(Elem);
3229 ring.push_front(Elem);
3230 ring.push_back(Elem);
3231 ring.push_front(Elem);
3233 drop(ring.pop_back());
3234 drop(ring.pop_front());
3237 drop(ring);
3253 let mut ring = LinkedList::new();
3254 ring.push_back(Elem);
3255 ring.push_front(Elem);
3256 ring.push_back(Elem);
3257 ring.push_front(Elem);
3258 ring.clear();
3261 drop(ring);
11795 let mut ring: VecDeque<i32> = (0..len as i32).collect();
11796 let orig = ring.clone();
11797 for _ in 0..ring.capacity() {
11799 ring.pop_front();
11800 for elt in &mut ring {
11803 ring.push_back(len - 1);
11804 assert_eq!(hash(&orig), hash(&ring));
11805 assert_eq!(orig, ring);
11806 assert_eq!(ring, orig);
11814 let mut ring: VecDeque<i32> = (0..len as i32).collect();
11815 let mut shifted = ring.clone();
11818 ring.pop_front();
11819 for elt in &mut ring {
11822 ring.push_back(len - 1);
11832 assert_eq!(shifted, ring);
11833 assert_eq!(ring, shifted);
11871 let mut ring = VecDeque::new();
11872 ring.push_back(Elem);
11873 ring.push_front(Elem);
11874 ring.push_back(Elem);
11875 ring.push_front(Elem);
11876 drop(ring);
11893 let mut ring = VecDeque::new();
11894 ring.push_back(Elem);
11895 ring.push_front(Elem);
11896 ring.push_back(Elem);
11897 ring.push_front(Elem);
11899 drop(ring.pop_back());
11900 drop(ring.pop_front());
11903 drop(ring);
11919 let mut ring = VecDeque::new();
11920 ring.push_back(Elem);
11921 ring.push_front(Elem);
11922 ring.push_back(Elem);
11923 ring.push_front(Elem);
11924 ring.clear();
11927 drop(ring);
11968 let mut ring = VecDeque::with_capacity(4);
11970 ring.push_back(i);
11972 ring.reserve(7);
11974 assert_eq!(ring.pop_front(), Some(i));
11979 let mut ring = VecDeque::with_capacity(4);
11981 ring.push_back(i);
11982 assert_eq!(ring.pop_front(), Some(i));
11985 ring.push_back(i);
11987 ring.reserve(7);
11989 assert_eq!(ring.pop_front(), Some(i));
11994 let mut ring = VecDeque::with_capacity(4);
11996 ring.push_back(i);
11997 assert_eq!(ring.pop_front(), Some(i));
12000 ring.push_back(i);
12002 ring.reserve(7);
12004 assert_eq!(ring.pop_front(), Some(i));
12010 let mut ring = VecDeque::new();
12011 ring.push_back(0);
12012 assert_eq!(ring.get(0), Some(&0));
12013 assert_eq!(ring.get(1), None);
12015 ring.push_back(1);
12016 assert_eq!(ring.get(0), Some(&0));
12017 assert_eq!(ring.get(1), Some(&1));
12018 assert_eq!(ring.get(2), None);
12020 ring.push_back(2);
12021 assert_eq!(ring.get(0), Some(&0));
12022 assert_eq!(ring.get(1), Some(&1));
12023 assert_eq!(ring.get(2), Some(&2));
12024 assert_eq!(ring.get(3), None);
12026 assert_eq!(ring.pop_front(), Some(0));
12027 assert_eq!(ring.get(0), Some(&1));
12028 assert_eq!(ring.get(1), Some(&2));
12029 assert_eq!(ring.get(2), None);
12031 assert_eq!(ring.pop_front(), Some(1));
12032 assert_eq!(ring.get(0), Some(&2));
12033 assert_eq!(ring.get(1), None);
12035 assert_eq!(ring.pop_front(), Some(2));
12036 assert_eq!(ring.get(0), None);
12037 assert_eq!(ring.get(1), None);
12042 let mut ring = VecDeque::new();
12044 ring.push_back(i);
12047 match ring.get_mut(1) {
12052 assert_eq!(ring.get_mut(0), Some(&mut 0));
12053 assert_eq!(ring.get_mut(1), Some(&mut -1));
12054 assert_eq!(ring.get_mut(2), Some(&mut 2));
12055 assert_eq!(ring.get_mut(3), None);
12057 assert_eq!(ring.pop_front(), Some(0));
12058 assert_eq!(ring.get_mut(0), Some(&mut -1));
12059 assert_eq!(ring.get_mut(1), Some(&mut 2));
12060 assert_eq!(ring.get_mut(2), None);
12065 let mut ring = VecDeque::new();
12066 ring.push_back(10);
12067 ring.push_back(20);
12068 assert_eq!(ring.front(), Some(&10));
12069 ring.pop_front();
12070 assert_eq!(ring.front(), Some(&20));
12071 ring.pop_front();
12072 assert_eq!(ring.front(), None);
12077 let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
12078 let cap = ring.capacity() as i32;
12082 ring.push_back(i);
12084 let (left, right) = ring.as_slices();
12091 ring.push_front(j);
12092 let (left, right) = ring.as_slices();
12099 assert_eq!(ring.len() as i32, cap);
12100 assert_eq!(ring.capacity() as i32, cap);
12105 let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
12106 let cap = ring.capacity() as i32;
12110 ring.push_back(i);
12112 let (left, right) = ring.as_mut_slices();
12119 ring.push_front(j);
12120 let (left, right) = ring.as_mut_slices();
12127 assert_eq!(ring.len() as i32, cap);
12128 assert_eq!(ring.capacity() as i32, cap);
40358 //! A double-ended queue implemented with a growable ring buffer.
40420 /// A double-ended queue implemented with a growable ring buffer.
40427 /// Since `VecDeque` is a ring buffer, its elements are not necessarily contiguous
40768 // Move the shortest contiguous section of the ring buffer
41281 Iter { tail: self.tail, head: self.head, ring: unsafe { self.buffer_as_slice() } }
41304 // `ring` we create is a dereferencable slice for lifetime '_.
41308 ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
41460 ring: unsafe { self.buffer_as_slice() },
41497 // `ring` we create is a dereferencable slice for lifetime '_.
41501 ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
41585 ring: unsafe { self.buffer_as_slice() },
41928 // Move the least number of elements in the ring buffer and insert
43295 pub(crate) ring: &'a [T],
43303 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
43312 Iter { ring: self.ring, tail: self.tail, head: self.head }
43326 self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
43327 unsafe { Some(self.ring.get_unchecked(tail)) }
43332 let len = count(self.tail, self.head, self.ring.len());
43340 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
43353 // single slice self.ring[self.tail..self.head]
43354 iter = self.ring[self.tail..self.head].iter();
43357 // two slices: self.ring[self.tail..], self.ring[..self.head]
43358 let (front, back) = self.ring.split_at(self.tail);
43361 let len = self.ring.len();
43362 self.tail = (self.ring.len() - back_iter.len()) & (len - 1);
43371 if n >= count(self.tail, self.head, self.ring.len()) {
43375 self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
43393 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
43394 self.ring.get_unchecked(idx)
43406 self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
43407 unsafe { Some(self.ring.get_unchecked(self.head)) }
43414 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
43427 // single slice self.ring[self.tail..self.head]
43428 iter = self.ring[self.tail..self.head].iter();
43431 // two slices: self.ring[self.tail..], self.ring[..self.head]
43432 let (front, back) = self.ring.split_at(self.tail);
43959 // Make capacity as a (2^x)-1, so that the ring size is 2^x
43980 // Now there's not (necessarily) space to straighten the ring with simple copies,
43981 // the ring will use swapping when:
44133 pub(crate) ring: *mut [T],
44149 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
44167 self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
44170 let elem = self.ring.get_unchecked_mut(tail);
44177 let len = count(self.tail, self.head, self.ring.len());
44185 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
44194 if n >= count(self.tail, self.head, self.ring.len()) {
44198 self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
44216 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
44217 &mut *self.ring.get_unchecked_mut(idx)
44229 self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
44232 let elem = self.ring.get_unchecked_mut(self.head);
44241 let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);