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