array_deque/
array_deque.rs

Help
1#[cfg(not(feature = "std"))]
2extern crate alloc;
3
4#[cfg(not(feature = "std"))]
5use alloc::{
6    alloc::{Layout, alloc, dealloc},
7    vec::Vec,
8};
9
10#[cfg(feature = "std")]
11use std::{
12    alloc::{Layout, alloc, dealloc},
13    vec::Vec,
14};
15
16use core::marker::PhantomData;
17use core::ops::{Index, IndexMut};
18use core::{fmt, ptr};
19
20#[cfg(feature = "serde")]
21use serde::{Deserialize, Deserializer, Serialize, Serializer};
22
23/// A fixed-capacity, heap-allocated double-ended queue backed by a circular buffer.
24///
25/// `ArrayDeque<T>` allocates a buffer on the heap with the given capacity. All
26/// insertions and removals at either end run in O(1) time. Once full, further
27/// `push_back` calls overwrite the oldest front element, and `push_front` calls
28/// overwrite the oldest back element (FIFO overwrite behavior).
29///
30/// # Examples
31///
32/// ```rust
33/// use array_deque::ArrayDeque;
34///
35/// let mut dq = ArrayDeque::new(3);
36/// dq.push_back("a");
37/// dq.push_back("b");
38/// dq.push_front("c");
39/// assert_eq!(dq.len(), 3);
40/// assert_eq!(dq[0], "c");
41///
42/// // Overflow: overwrites the back ("b")
43/// dq.push_front("x");
44/// assert_eq!(dq.pop_back(), Some("a"));
45/// ```
46pub struct ArrayDeque<T> {
47    /// Raw pointer to the allocated memory
48    ptr: *mut T,
49    /// Maximum capacity of the deque
50    cap: usize,
51    /// Current number of elements
52    len: usize,
53    /// Index of the front element
54    idx: usize,
55    /// Marker for the generic type
56    _marker: PhantomData<T>,
57}
58
59impl<T> ArrayDeque<T> {
60    /// Creates a new `ArrayDeque` with the specified capacity.
61    ///
62    /// # Arguments
63    ///
64    /// * `cap` - The fixed capacity of the deque. Must be greater than zero.
65    ///
66    /// # Panics
67    ///
68    /// Panics if `cap` is zero or if memory allocation fails.
69    ///
70    /// # Examples
71    ///
72    /// ```
73    /// use array_deque::ArrayDeque;
74    ///
75    /// let deque: ArrayDeque<i32> = ArrayDeque::new(10);
76    /// assert_eq!(deque.capacity(), 10);
77    /// assert!(deque.is_empty());
78    /// ```
79    pub fn new(cap: usize) -> Self {
80        assert!(cap > 0, "Capacity must be greater than zero");
81
82        let layout = Layout::array::<T>(cap).expect("Invalid layout");
83        let ptr = unsafe { alloc(layout) as *mut T };
84
85        if ptr.is_null() {
86            panic!("Failed to allocate memory");
87        }
88
89        Self {
90            ptr,
91            cap,
92            len: 0,
93            idx: 0,
94            _marker: PhantomData,
95        }
96    }
97
98    /// Appends an element to the back of the deque.
99    ///
100    /// If the deque is at capacity, this will overwrite the front element
101    /// and advance the front pointer.
102    ///
103    /// # Arguments
104    ///
105    /// * `value` - The element to append
106    ///
107    /// # Examples
108    ///
109    /// ```
110    /// use array_deque::ArrayDeque;
111    ///
112    /// let mut deque = ArrayDeque::new(3);
113    /// deque.push_back(1);
114    /// deque.push_back(2);
115    /// assert_eq!(deque.len(), 2);
116    /// ```
117    pub fn push_back(&mut self, value: T) {
118        let write_idx = (self.idx + self.len) % self.cap;
119        unsafe {
120            ptr::write(self.ptr.add(write_idx), value);
121        }
122        if self.len == self.cap {
123            self.idx = (self.idx + 1) % self.cap;
124        } else {
125            self.len += 1;
126        }
127    }
128
129    /// Prepends an element to the front of the deque.
130    ///
131    /// If the deque is at capacity, this will overwrite the back element.
132    ///
133    /// # Arguments
134    ///
135    /// * `value` - The element to prepend
136    ///
137    /// # Examples
138    ///
139    /// ```
140    /// use array_deque::ArrayDeque;
141    ///
142    /// let mut deque = ArrayDeque::new(3);
143    /// deque.push_front(1);
144    /// deque.push_front(2);
145    /// assert_eq!(deque[0], 2);
146    /// assert_eq!(deque[1], 1);
147    /// ```
148    pub fn push_front(&mut self, value: T) {
149        self.idx = (self.idx + self.cap - 1) % self.cap;
150        if self.len == self.cap {
151            let drop_idx = (self.idx + self.len) % self.cap;
152            unsafe {
153                ptr::drop_in_place(self.ptr.add(drop_idx));
154            }
155        } else {
156            self.len += 1;
157        }
158        unsafe {
159            ptr::write(self.ptr.add(self.idx), value);
160        }
161    }
162
163    /// Removes and returns the last element from the deque.
164    ///
165    /// # Returns
166    ///
167    /// `Some(T)` if the deque is not empty, `None` otherwise.
168    ///
169    /// # Examples
170    ///
171    /// ```
172    /// use array_deque::ArrayDeque;
173    ///
174    /// let mut deque = ArrayDeque::new(3);
175    /// deque.push_back(1);
176    /// deque.push_back(2);
177    /// assert_eq!(deque.pop_back(), Some(2));
178    /// assert_eq!(deque.pop_back(), Some(1));
179    /// assert_eq!(deque.pop_back(), None);
180    /// ```
181    pub fn pop_back(&mut self) -> Option<T> {
182        if self.len == 0 {
183            return None;
184        }
185        let tail_idx = (self.idx + self.len - 1) % self.cap;
186        self.len -= 1;
187        Some(unsafe { ptr::read(self.ptr.add(tail_idx)) })
188    }
189
190    /// Removes and returns the first element from the deque.
191    ///
192    /// # Returns
193    ///
194    /// `Some(T)` if the deque is not empty, `None` otherwise.
195    ///
196    /// # Examples
197    ///
198    /// ```
199    /// use array_deque::ArrayDeque;
200    ///
201    /// let mut deque = ArrayDeque::new(3);
202    /// deque.push_back(1);
203    /// deque.push_back(2);
204    /// assert_eq!(deque.pop_front(), Some(1));
205    /// assert_eq!(deque.pop_front(), Some(2));
206    /// assert_eq!(deque.pop_front(), None);
207    /// ```
208    pub fn pop_front(&mut self) -> Option<T> {
209        if self.len == 0 {
210            return None;
211        }
212        let front_idx = self.idx;
213        self.idx = (self.idx + 1) % self.cap;
214        self.len -= 1;
215        Some(unsafe { ptr::read(self.ptr.add(front_idx)) })
216    }
217
218    /// Returns a reference to the front element without removing it.
219    ///
220    /// # Examples
221    ///
222    /// ```
223    /// use array_deque::ArrayDeque;
224    ///
225    /// let mut dq = ArrayDeque::new(3);
226    /// assert_eq!(dq.front(), None);
227    /// dq.push_back(42);
228    /// assert_eq!(dq.front(), Some(&42));
229    /// ```
230    pub fn front(&self) -> Option<&T> {
231        if self.is_empty() {
232            None
233        } else {
234            Some(unsafe { &*self.ptr.add(self.idx) })
235        }
236    }
237
238    /// Returns a reference to the back element without removing it.
239    ///
240    /// # Examples
241    ///
242    /// ```
243    /// use array_deque::ArrayDeque;
244    ///
245    /// let mut dq = ArrayDeque::new(3);
246    /// dq.push_back(1);
247    /// dq.push_back(2);
248    /// assert_eq!(dq.back(), Some(&2));
249    /// ```
250    pub fn back(&self) -> Option<&T> {
251        if self.is_empty() {
252            None
253        } else {
254            let back_idx = if self.idx + self.len <= self.cap {
255                self.idx + self.len - 1
256            } else {
257                (self.idx + self.len - 1) % self.cap
258            };
259            Some(unsafe { &*self.ptr.add(back_idx) })
260        }
261    }
262
263    /// Returns an iterator over the elements of the deque (front to back).
264    ///
265    /// # Examples
266    ///
267    /// ```
268    /// use array_deque::ArrayDeque;
269    ///
270    /// let mut dq = ArrayDeque::new(3);
271    /// dq.push_back(1);
272    /// dq.push_back(2);
273    /// let v: Vec<_> = dq.iter().cloned().collect();
274    /// assert_eq!(v, vec![1,2]);
275    /// ```
276    pub fn iter(&self) -> impl Iterator<Item = &T> {
277        (0..self.len).map(move |i| {
278            let idx = (self.idx + i) % self.cap;
279            unsafe { &*self.ptr.add(idx) }
280        })
281    }
282
283    /// Returns the maximum capacity of the deque.
284    ///
285    /// # Examples
286    ///
287    /// ```
288    /// use array_deque::ArrayDeque;
289    ///
290    /// let dq: ArrayDeque<i32> = ArrayDeque::new(5);
291    /// assert_eq!(dq.capacity(), 5);
292    /// ```
293    pub fn capacity(&self) -> usize {
294        self.cap
295    }
296
297    /// Returns the number of elements currently in the deque.
298    ///
299    /// # Examples
300    ///
301    /// ```
302    /// use array_deque::ArrayDeque;
303    ///
304    /// let mut dq = ArrayDeque::new(3);
305    /// assert_eq!(dq.len(), 0);
306    /// dq.push_back(1);
307    /// assert_eq!(dq.len(), 1);
308    /// ```
309    pub fn len(&self) -> usize {
310        self.len
311    }
312
313    /// Returns `true` if the deque contains no elements.
314    ///
315    /// # Examples
316    ///
317    /// ```
318    /// use array_deque::ArrayDeque;
319    ///
320    /// let mut dq = ArrayDeque::new(3);
321    /// assert!(dq.is_empty());
322    /// dq.push_back(1);
323    /// assert!(!dq.is_empty());
324    /// ```
325    pub fn is_empty(&self) -> bool {
326        self.len == 0
327    }
328
329    /// Returns `true` if the deque has reached its maximum capacity.
330    ///
331    /// # Examples
332    ///
333    /// ```
334    /// use array_deque::ArrayDeque;
335    ///
336    /// let mut dq = ArrayDeque::new(2);
337    /// dq.push_back(1);
338    /// dq.push_back(2);
339    /// assert!(dq.is_full());
340    /// ```
341    pub fn is_full(&self) -> bool {
342        self.len == self.cap
343    }
344
345    /// Removes all elements from the deque, properly dropping them,
346    /// and resets it to an empty state.
347    ///
348    /// # Examples
349    ///
350    /// ```
351    /// use array_deque::ArrayDeque;
352    ///
353    /// let mut dq = ArrayDeque::new(3);
354    /// dq.push_back(1);
355    /// dq.clear();
356    /// assert!(dq.is_empty());
357    /// assert_eq!(dq.len(), 0);
358    /// ```
359    pub fn clear(&mut self) {
360        for i in 0..self.len {
361            let idx = (self.idx + i) % self.cap;
362            unsafe {
363                ptr::drop_in_place(self.ptr.add(idx));
364            }
365        }
366        self.len = 0;
367        self.idx = 0;
368    }
369}
370
371impl<T> Drop for ArrayDeque<T> {
372    /// Drops all elements and deallocates the heap buffer.
373    fn drop(&mut self) {
374        self.clear();
375        let layout = Layout::array::<T>(self.cap).expect("Invalid layout");
376        unsafe {
377            dealloc(self.ptr.cast(), layout);
378        }
379    }
380}
381
382impl<T: fmt::Debug> fmt::Debug for ArrayDeque<T> {
383    /// Formats the deque as a debug list (front to back).
384    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
385        f.debug_list().entries(self.iter()).finish()
386    }
387}
388
389impl<T: Clone> Clone for ArrayDeque<T> {
390    /// Creates a deep copy of the deque with identical capacity and contents.
391    ///
392    /// # Examples
393    ///
394    /// ```
395    /// use array_deque::ArrayDeque;
396    ///
397    /// let mut deque = ArrayDeque::new(3);
398    /// deque.push_back(1);
399    /// deque.push_back(2);
400    /// let cloned = deque.clone();
401    /// assert_eq!(deque.len(), cloned.len());
402    /// assert_eq!(deque[0], cloned[0]);
403    /// ```
404    fn clone(&self) -> Self {
405        let mut new = ArrayDeque::new(self.cap);
406        for item in self.iter() {
407            new.push_back(item.clone());
408        }
409        new
410    }
411}
412
413impl<T: PartialEq> PartialEq for ArrayDeque<T> {
414    /// Two deques are equal if they have the same length
415    /// and each element compares equal in order.
416    fn eq(&self, other: &Self) -> bool {
417        self.len == other.len && self.iter().eq(other.iter())
418    }
419}
420
421impl<T: Eq> Eq for ArrayDeque<T> {}
422
423impl<T> Index<usize> for ArrayDeque<T> {
424    type Output = T;
425
426    /// Indexed access into the deque (0 is front).
427    ///
428    /// # Panics
429    ///
430    /// Panics if `index >= len()`.
431    fn index(&self, index: usize) -> &Self::Output {
432        assert!(index < self.len, "Index out of bounds");
433        let actual_idx = self.idx + index;
434        let actual_idx = if actual_idx >= self.cap {
435            actual_idx - self.cap
436        } else {
437            actual_idx
438        };
439        unsafe { &*self.ptr.add(actual_idx) }
440    }
441}
442
443impl<T> IndexMut<usize> for ArrayDeque<T> {
444    /// Mutable indexed access into the deque (0 is front).
445    ///
446    /// # Panics
447    ///
448    /// Panics if `index >= len()`.
449    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
450        assert!(index < self.len);
451        let idx = (self.idx + index) % self.cap;
452        unsafe { &mut *self.ptr.add(idx) }
453    }
454}
455
456impl<T> Extend<T> for ArrayDeque<T> {
457    /// Extends the deque by pushing each item of the iterator to the back.
458    ///
459    /// # Examples
460    ///
461    /// ```
462    /// use array_deque::ArrayDeque;
463    ///
464    /// let mut dq = ArrayDeque::new(5);
465    /// dq.extend([1,2,3]);
466    /// assert_eq!(dq.len(), 3);
467    /// ```
468    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
469        for item in iter {
470            self.push_back(item);
471        }
472    }
473}
474
475impl<T> FromIterator<T> for ArrayDeque<T> {
476    /// Creates a deque from an iterator by collecting all items.
477    /// Capacity == number of items (min 1).
478    ///
479    /// # Examples
480    ///
481    /// ```
482    /// use array_deque::ArrayDeque;
483    ///
484    /// let dq: ArrayDeque<_> = (0..3).collect();
485    /// assert_eq!(dq.len(), 3);
486    /// ```
487    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
488        let vec: Vec<T> = iter.into_iter().collect();
489        let mut deque = ArrayDeque::new(vec.len().max(1));
490        deque.extend(vec);
491        deque
492    }
493}
494
495impl<T: Clone> From<&[T]> for ArrayDeque<T> {
496    /// Clones all elements from a slice into a new deque.
497    fn from(slice: &[T]) -> Self {
498        let mut deque = ArrayDeque::new(slice.len());
499        for item in slice {
500            deque.push_back(item.clone());
501        }
502        deque
503    }
504}
505
506impl<T, const N: usize> From<[T; N]> for ArrayDeque<T> {
507    /// Takes ownership of each element in the array.
508    fn from(array: [T; N]) -> Self {
509        let mut deque = ArrayDeque::new(N.max(1));
510        for item in array {
511            deque.push_back(item);
512        }
513        deque
514    }
515}
516
517impl<T> From<Vec<T>> for ArrayDeque<T> {
518    /// Takes ownership of each element in the vector.
519    fn from(vec: Vec<T>) -> Self {
520        let mut deque = ArrayDeque::new(vec.len().max(1));
521        for item in vec {
522            deque.push_back(item);
523        }
524        deque
525    }
526}
527
528impl<T: Clone> From<&Vec<T>> for ArrayDeque<T> {
529    /// Clones each element from the vector.
530    fn from(vec: &Vec<T>) -> Self {
531        let mut deque = ArrayDeque::new(vec.len().max(1));
532        for item in vec {
533            deque.push_back(item.clone());
534        }
535        deque
536    }
537}
538
539impl<T: Clone, const N: usize> From<&[T; N]> for ArrayDeque<T> {
540    /// Clones each element from the array reference.
541    fn from(array: &[T; N]) -> Self {
542        let mut deque = ArrayDeque::new(N.max(1));
543        for item in array {
544            deque.push_back(item.clone());
545        }
546        deque
547    }
548}
549
550#[cfg(feature = "serde")]
551impl<T: Serialize> Serialize for ArrayDeque<T> {
552    /// Serializes the deque as a sequence (front to back).
553    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
554    where
555        S: Serializer,
556    {
557        use serde::ser::SerializeSeq;
558
559        let mut seq = serializer.serialize_seq(Some(self.len))?;
560        for item in self.iter() {
561            seq.serialize_element(item)?;
562        }
563        seq.end()
564    }
565}
566
567#[cfg(feature = "serde")]
568impl<'de, T: Deserialize<'de>> Deserialize<'de> for ArrayDeque<T> {
569    /// Deserializes a sequence into a deque (capacity == item count).
570    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
571    where
572        D: Deserializer<'de>,
573    {
574        let vec: Vec<T> = Vec::deserialize(deserializer)?;
575        Ok(ArrayDeque::from(vec))
576    }
577}
578
579impl<T> IntoIterator for ArrayDeque<T> {
580    type Item = T;
581    type IntoIter = ArrayDequeIntoIter<T>;
582    /// Consumes the deque and returns an iterator over its elements.
583    fn into_iter(self) -> Self::IntoIter {
584        ArrayDequeIntoIter {
585            deque: self,
586            pos: 0,
587        }
588    }
589}
590
591/// An owning iterator that moves elements out of an `ArrayDeque`.
592///
593/// Returned by `into_iter()`.
594pub struct ArrayDequeIntoIter<T> {
595    deque: ArrayDeque<T>,
596    pos: usize,
597}
598
599impl<T> Iterator for ArrayDequeIntoIter<T> {
600    type Item = T;
601
602    /// Advances and returns the next element.
603    fn next(&mut self) -> Option<T> {
604        if self.pos >= self.deque.len {
605            return None;
606        }
607        let idx = (self.deque.idx + self.pos) % self.deque.cap;
608        self.pos += 1;
609        Some(unsafe { ptr::read(self.deque.ptr.add(idx)) })
610    }
611}
612
613impl<'a, T> IntoIterator for &'a ArrayDeque<T> {
614    type Item = &'a T;
615    type IntoIter = ArrayDequeIter<'a, T>;
616    /// Borrows the deque and returns an iterator over `&T`.
617    fn into_iter(self) -> Self::IntoIter {
618        ArrayDequeIter {
619            deque: self,
620            pos: 0,
621        }
622    }
623}
624
625/// A borrowed iterator over `&T` from an `ArrayDeque`.
626///
627/// Returned by `iter()` and `&deque.into_iter()`.
628pub struct ArrayDequeIter<'a, T> {
629    deque: &'a ArrayDeque<T>,
630    pos: usize,
631}
632
633impl<'a, T> Iterator for ArrayDequeIter<'a, T> {
634    type Item = &'a T;
635
636    /// Advances and returns the next reference.
637    fn next(&mut self) -> Option<&'a T> {
638        if self.pos >= self.deque.len {
639            return None;
640        }
641        let idx = (self.deque.idx + self.pos) % self.deque.cap;
642        self.pos += 1;
643        unsafe { Some(&*self.deque.ptr.add(idx)) }
644    }
645}
646
647impl<'a, T> ExactSizeIterator for ArrayDequeIter<'a, T> {}
648
649#[cfg(test)]
650mod tests {
651    use super::*;
652
653    #[test]
654    fn push_pop() {
655        let mut deque = ArrayDeque::new(3);
656        deque.push_back(1);
657        deque.push_back(2);
658        deque.push_back(3);
659        assert_eq!(deque.pop_front(), Some(1));
660        assert_eq!(deque.pop_back(), Some(3));
661        assert_eq!(deque.pop_front(), Some(2));
662        assert_eq!(deque.pop_front(), None);
663    }
664
665    #[test]
666    fn push_front_back() {
667        let mut deque = ArrayDeque::new(3);
668        deque.push_front(1);
669        deque.push_front(2);
670        deque.push_back(3);
671        assert_eq!(deque.pop_front(), Some(2));
672        assert_eq!(deque.pop_back(), Some(3));
673        assert_eq!(deque.pop_front(), Some(1));
674        assert_eq!(deque.pop_front(), None);
675    }
676
677    #[test]
678    fn iter() {
679        let mut deque = ArrayDeque::new(5);
680        deque.push_back(1);
681        deque.push_back(2);
682        deque.push_back(3);
683        let mut iter = deque.iter();
684        assert_eq!(iter.next(), Some(&1));
685        assert_eq!(iter.next(), Some(&2));
686        assert_eq!(iter.next(), Some(&3));
687        assert_eq!(iter.next(), None);
688    }
689
690    #[test]
691    fn clear() {
692        let mut deque = ArrayDeque::new(3);
693        deque.push_back(1);
694        deque.push_back(2);
695        deque.clear();
696        assert!(deque.is_empty());
697        assert_eq!(deque.len(), 0);
698    }
699
700    #[test]
701    fn capacity() {
702        let deque = ArrayDeque::<i32>::new(5);
703        assert_eq!(deque.capacity(), 5);
704        assert!(deque.is_empty());
705    }
706
707    #[test]
708    fn clone() {
709        let mut deque = ArrayDeque::new(3);
710        deque.push_back(1);
711        deque.push_back(2);
712        let cloned_deque = deque.clone();
713        assert_eq!(cloned_deque.len(), 2);
714        assert_eq!(cloned_deque[0], 1);
715        assert_eq!(cloned_deque[1], 2);
716    }
717
718    #[test]
719    fn from_iter() {
720        let vec = vec![1, 2, 3];
721        let deque: ArrayDeque<_> = vec.into_iter().collect();
722        assert_eq!(deque.len(), 3);
723        assert_eq!(deque[0], 1);
724        assert_eq!(deque[1], 2);
725        assert_eq!(deque[2], 3);
726    }
727
728    #[test]
729    fn from_slice() {
730        let slice = [1, 2, 3];
731        let deque: ArrayDeque<_> = ArrayDeque::from(&slice[..]);
732        assert_eq!(deque.len(), 3);
733        assert_eq!(deque[0], 1);
734        assert_eq!(deque[1], 2);
735        assert_eq!(deque[2], 3);
736    }
737
738    #[test]
739    fn from_array() {
740        let array = [1, 2, 3];
741        let deque: ArrayDeque<_> = ArrayDeque::from(array);
742        assert_eq!(deque.len(), 3);
743        assert_eq!(deque[0], 1);
744        assert_eq!(deque[1], 2);
745        assert_eq!(deque[2], 3);
746    }
747
748    #[test]
749    fn index() {
750        let mut deque = ArrayDeque::new(5);
751        deque.push_back(1);
752        deque.push_back(2);
753        deque.push_back(3);
754        assert_eq!(deque[0], 1);
755        assert_eq!(deque[1], 2);
756        assert_eq!(deque[2], 3);
757        assert!(
758            std::panic::catch_unwind(|| {
759                let _ = deque[3];
760            })
761            .is_err()
762        );
763    }
764
765    #[test]
766    fn index_mut() {
767        let mut deque = ArrayDeque::new(5);
768        deque.push_back(1);
769        deque.push_back(2);
770        deque.push_back(3);
771        deque[0] = 10;
772        assert_eq!(deque[0], 10);
773        assert_eq!(deque[1], 2);
774        assert_eq!(deque[2], 3);
775        assert!(
776            std::panic::catch_unwind(|| {
777                let _ = deque[3];
778            })
779            .is_err()
780        );
781    }
782
783    #[test]
784    fn extend() {
785        let mut deque = ArrayDeque::new(5);
786        deque.extend(vec![1, 2, 3]);
787        assert_eq!(deque.len(), 3);
788        assert_eq!(deque[0], 1);
789        assert_eq!(deque[1], 2);
790        assert_eq!(deque[2], 3);
791    }
792
793    #[test]
794    fn into_iter() {
795        let mut deque = ArrayDeque::new(5);
796        deque.push_back(1);
797        deque.push_back(2);
798        deque.push_back(3);
799        let mut iter = deque.into_iter();
800        assert_eq!(iter.next(), Some(1));
801        assert_eq!(iter.next(), Some(2));
802        assert_eq!(iter.next(), Some(3));
803        assert_eq!(iter.next(), None);
804    }
805
806    #[test]
807    fn into_iter_empty() {
808        let deque: ArrayDeque<i32> = ArrayDeque::new(5);
809        let mut iter = deque.into_iter();
810        assert_eq!(iter.next(), None);
811    }
812
813    #[test]
814    fn into_iter_full() {
815        let mut deque = ArrayDeque::new(3);
816        deque.push_back(1);
817        deque.push_back(2);
818        deque.push_back(3);
819        let mut iter = deque.into_iter();
820        assert_eq!(iter.next(), Some(1));
821        assert_eq!(iter.next(), Some(2));
822        assert_eq!(iter.next(), Some(3));
823        assert_eq!(iter.next(), None);
824    }
825
826    #[test]
827    fn into_iter_partial() {
828        let mut deque = ArrayDeque::new(5);
829        deque.push_back(1);
830        deque.push_back(2);
831        let mut iter = deque.into_iter();
832        assert_eq!(iter.next(), Some(1));
833        assert_eq!(iter.next(), Some(2));
834        assert_eq!(iter.next(), None);
835    }
836
837    #[test]
838    fn iter_empty() {
839        let deque: ArrayDeque<i32> = ArrayDeque::new(5);
840        let mut iter = deque.iter();
841        assert_eq!(iter.next(), None);
842    }
843
844    #[test]
845    fn iter_full() {
846        let mut deque = ArrayDeque::new(3);
847        deque.push_back(1);
848        deque.push_back(2);
849        deque.push_back(3);
850        let mut iter = deque.iter();
851        assert_eq!(iter.next(), Some(&1));
852        assert_eq!(iter.next(), Some(&2));
853        assert_eq!(iter.next(), Some(&3));
854        assert_eq!(iter.next(), None);
855    }
856
857    #[test]
858    fn iter_partial() {
859        let mut deque = ArrayDeque::new(5);
860        deque.push_back(1);
861        deque.push_back(2);
862        let mut iter = deque.iter();
863        assert_eq!(iter.next(), Some(&1));
864        assert_eq!(iter.next(), Some(&2));
865        assert_eq!(iter.next(), None);
866    }
867
868    #[test]
869    fn is_empty() {
870        let deque: ArrayDeque<i32> = ArrayDeque::new(5);
871        assert!(deque.is_empty());
872        assert_eq!(deque.len(), 0);
873    }
874
875    #[test]
876    fn is_full() {
877        let mut deque = ArrayDeque::new(3);
878        assert!(!deque.is_full());
879        deque.push_back(1);
880        deque.push_back(2);
881        assert!(!deque.is_full());
882        deque.push_back(3);
883        assert!(deque.is_full());
884    }
885
886    #[test]
887    fn clear_empty() {
888        let mut deque = ArrayDeque::<()>::new(3);
889        deque.clear();
890        assert!(deque.is_empty());
891        assert_eq!(deque.len(), 0);
892    }
893
894    #[test]
895    fn clear_non_empty() {
896        let mut deque = ArrayDeque::new(3);
897        deque.push_back(1);
898        deque.push_back(2);
899        deque.clear();
900        assert!(deque.is_empty());
901        assert_eq!(deque.len(), 0);
902    }
903
904    #[test]
905    #[cfg(feature = "serde")]
906    fn serde_serialize() {
907        let mut deque = ArrayDeque::new(3);
908        deque.push_back(1);
909        deque.push_back(2);
910        let serialized = serde_json::to_string(&deque).unwrap();
911        assert_eq!(serialized, "[1,2]");
912    }
913
914    #[test]
915    #[cfg(feature = "serde")]
916    fn serde_deserialize() {
917        let serialized = "[1,2,3]";
918        let deque: ArrayDeque<i32> = serde_json::from_str(serialized).unwrap();
919        assert_eq!(deque.len(), 3);
920        assert_eq!(deque[0], 1);
921        assert_eq!(deque[1], 2);
922        assert_eq!(deque[2], 3);
923    }
924}
array_deque/array_deque.rs

array_deque/
array_deque.rs
