qudit_core/utils/
limited.rs

1use std::alloc::{Layout, alloc, dealloc};
2use std::fmt;
3use std::hash::Hash;
4use std::ptr::NonNull;
5
6/// A vector-like container with 32-bit length and capacity limits.
7///
8/// `LimitedSizeVec` is a performance-optimized vector implementation that uses
9/// `u32` for length and capacity instead of `usize`, limiting the maximum
10/// number of elements to 2³² - 1 (approximately 4.3 billion elements).
11/// This reduces memory overhead on 64-bit systems where the smaller size
12/// representation can improve cache performance.
13///
14/// # Memory Layout
15///
16/// The struct uses manual memory management with raw pointers for optimal
17/// performance. Memory is allocated using the global allocator and grows
18/// by doubling capacity when needed.
19///
20/// # Safety
21///
22/// This implementation maintains memory safety through careful pointer
23/// arithmetic and proper Drop implementation. All unsafe operations are
24/// encapsulated within safe public methods.
25///
26/// # Limits
27///
28/// - Maximum capacity: `u32::MAX` (4,294,967,295 elements)
29/// - Initial capacity: 8 elements (when using `new()`)
30/// - Growth factor: 2x when capacity is exceeded
31///
32/// # Examples
33///
34/// ```rust
35/// # use qudit_core::LimitedSizeVec;
36///
37/// // Create a new vector
38/// let mut vec = LimitedSizeVec::new();
39/// assert_eq!(vec.len(), 0);
40/// assert_eq!(vec.capacity(), 8);
41///
42/// // Add elements
43/// vec.push("hello");
44/// vec.push("world");
45/// assert_eq!(vec.len(), 2);
46///
47/// // Access elements
48/// assert_eq!(vec[0], "hello");
49/// assert_eq!(vec.get(1), Some(&"world"));
50///
51/// // Convert to slice
52/// let slice: &[&str] = vec.as_slice();
53/// assert_eq!(slice, ["hello", "world"]);
54/// ```
55#[repr(C)]
56pub struct LimitedSizeVec<T> {
57    data: NonNull<T>,
58    len: u32,
59    capacity: u32,
60}
61
62/// Default initial capacity for new vectors
63const DEFAULT_CAPACITY: u32 = 8;
64
65impl<T> LimitedSizeVec<T> {
66    /// Creates a new empty vector with default capacity.
67    ///
68    /// The vector will initially allocate space for 8 elements.
69    ///
70    /// # Examples
71    ///
72    /// ```rust
73    /// use qudit_core::LimitedSizeVec;
74    ///
75    /// let vec: LimitedSizeVec<i32> = LimitedSizeVec::new();
76    /// assert_eq!(vec.len(), 0);
77    /// assert_eq!(vec.capacity(), 8);
78    /// ```
79    #[inline]
80    pub fn new() -> Self {
81        Self::new_with_capacity(DEFAULT_CAPACITY)
82    }
83
84    /// Creates a new empty vector with the specified capacity.
85    ///
86    /// # Arguments
87    /// * `capacity` - The initial capacity (must be > 0)
88    ///
89    /// # Panics
90    /// Panics if capacity is 0 or if memory allocation fails.
91    ///
92    /// # Examples
93    ///
94    /// ```rust
95    /// use qudit_core::LimitedSizeVec;
96    ///
97    /// let vec: LimitedSizeVec<i32> = LimitedSizeVec::new_with_capacity(100);
98    /// assert_eq!(vec.len(), 0);
99    /// assert_eq!(vec.capacity(), 100);
100    /// ```
101    #[inline]
102    pub fn new_with_capacity(capacity: u32) -> Self {
103        if capacity == 0 {
104            Self::zero_capacity_panic();
105        }
106
107        let layout =
108            Layout::array::<T>(capacity as usize).unwrap_or_else(|_| Self::layout_error_panic());
109
110        let ptr = unsafe { alloc(layout) as *mut T };
111        let non_null = NonNull::new(ptr).unwrap_or_else(|| Self::allocation_failed_panic());
112
113        Self {
114            data: non_null,
115            len: 0,
116            capacity,
117        }
118    }
119
120    #[cold]
121    #[inline(never)]
122    fn zero_capacity_panic() -> ! {
123        panic!("Cannot create vector with zero capacity");
124    }
125
126    #[cold]
127    #[inline(never)]
128    fn layout_error_panic() -> ! {
129        panic!("Failed to create memory layout for vector");
130    }
131
132    #[cold]
133    #[inline(never)]
134    fn allocation_failed_panic() -> ! {
135        panic!("Memory allocation failed");
136    }
137
138    /// Appends an element to the back of the vector.
139    ///
140    /// If the vector's capacity is exceeded, it will be reallocated with
141    /// double the previous capacity.
142    ///
143    /// # Arguments
144    /// * `value` - The element to append
145    ///
146    /// # Examples
147    ///
148    /// ```rust
149    /// # use qudit_core::LimitedSizeVec;
150    ///
151    /// let mut vec = LimitedSizeVec::new();
152    /// vec.push(42);
153    /// vec.push(100);
154    /// assert_eq!(vec.len(), 2);
155    /// assert_eq!(vec[0], 42);
156    /// assert_eq!(vec[1], 100);
157    /// ```
158    #[inline]
159    pub fn push(&mut self, value: T) {
160        if self.len >= self.capacity {
161            self.grow();
162        }
163        unsafe {
164            self.data.as_ptr().add(self.len as usize).write(value);
165        }
166        self.len += 1;
167    }
168
169    /// Grows the vector's capacity.
170    ///
171    /// Doubles the current capacity, with a minimum of 8 elements.
172    /// This method is called automatically when needed by `push()`.
173    fn grow(&mut self) {
174        let new_capacity = if self.capacity == 0 {
175            DEFAULT_CAPACITY
176        } else {
177            self.capacity.saturating_mul(2)
178        };
179
180        unsafe {
181            let new_layout = Layout::array::<T>(new_capacity as usize).unwrap();
182            let new_ptr = alloc(new_layout) as *mut T;
183
184            if new_ptr.is_null() {
185                Self::allocation_failed_panic();
186            }
187
188            // Zero capacity only possible with dangling pointer; special case
189            if self.capacity != 0 {
190                let old_ptr = self.data.as_ptr();
191                std::ptr::copy_nonoverlapping(old_ptr, new_ptr, self.len as usize);
192                let old_layout = Layout::array::<T>(self.capacity as usize).unwrap();
193                dealloc(old_ptr as *mut u8, old_layout);
194            }
195
196            self.data = NonNull::new(new_ptr).unwrap();
197        }
198        self.capacity = new_capacity;
199    }
200
201    /// Grows the vector's capacity to at least the specified capacity.
202    fn grow_to_capacity(&mut self, new_capacity: u32) {
203        if new_capacity <= self.capacity {
204            return;
205        }
206
207        unsafe {
208            let new_layout = Layout::array::<T>(new_capacity as usize).unwrap();
209            let new_ptr = alloc(new_layout) as *mut T;
210
211            if new_ptr.is_null() {
212                Self::allocation_failed_panic();
213            }
214
215            // Copy existing elements if any
216            if self.capacity != 0 {
217                let old_ptr = self.data.as_ptr();
218                std::ptr::copy_nonoverlapping(old_ptr, new_ptr, self.len as usize);
219                let old_layout = Layout::array::<T>(self.capacity as usize).unwrap();
220                dealloc(old_ptr as *mut u8, old_layout);
221            }
222
223            self.data = NonNull::new(new_ptr).unwrap();
224        }
225        self.capacity = new_capacity;
226    }
227
228    /// Returns the number of elements in the vector.
229    ///
230    /// # Examples
231    ///
232    /// ```rust
233    /// # use qudit_core::LimitedSizeVec;
234    ///
235    /// let mut vec = LimitedSizeVec::new();
236    /// assert_eq!(vec.len(), 0);
237    ///
238    /// vec.push("hello");
239    /// assert_eq!(vec.len(), 1);
240    /// ```
241    #[inline(always)]
242    pub fn len(&self) -> usize {
243        self.len as usize
244    }
245
246    /// Returns the total capacity of the vector.
247    ///
248    /// # Examples
249    ///
250    /// ```rust
251    /// # use qudit_core::LimitedSizeVec;
252    ///
253    /// let vec: LimitedSizeVec<i32> = LimitedSizeVec::new_with_capacity(50);
254    /// assert_eq!(vec.capacity(), 50);
255    /// ```
256    #[inline(always)]
257    pub fn capacity(&self) -> usize {
258        self.capacity as usize
259    }
260
261    /// Returns `true` if the vector contains no elements.
262    ///
263    /// # Examples
264    ///
265    /// ```rust
266    /// # use qudit_core::LimitedSizeVec;
267    ///
268    /// let mut vec = LimitedSizeVec::new();
269    /// assert!(vec.is_empty());
270    ///
271    /// vec.push(42);
272    /// assert!(!vec.is_empty());
273    /// ```
274    #[inline(always)]
275    pub const fn is_empty(&self) -> bool {
276        self.len == 0
277    }
278
279    /// Returns a reference to the element at the given index, or `None` if out of bounds.
280    ///
281    /// # Arguments
282    /// * `index` - The index to access
283    ///
284    /// # Examples
285    ///
286    /// ```rust
287    /// # use qudit_core::LimitedSizeVec;
288    ///
289    /// let mut vec = LimitedSizeVec::new();
290    /// vec.push("hello");
291    ///
292    /// assert_eq!(vec.get(0), Some(&"hello"));
293    /// assert_eq!(vec.get(1), None);
294    /// ```
295    #[inline]
296    pub fn get(&self, index: usize) -> Option<&T> {
297        if index < self.len as usize {
298            unsafe { Some(&*self.data.as_ptr().add(index)) }
299        } else {
300            None
301        }
302    }
303
304    /// Returns a mutable reference to the element at the given index, or `None` if out of bounds.
305    ///
306    /// # Arguments
307    /// * `index` - The index to access
308    ///
309    /// # Examples
310    ///
311    /// ```rust
312    /// # use qudit_core::LimitedSizeVec;
313    ///
314    /// let mut vec = LimitedSizeVec::new();
315    /// vec.push(String::from("hello"));
316    ///
317    /// if let Some(element) = vec.get_mut(0) {
318    ///     element.push_str(" world");
319    /// }
320    /// assert_eq!(vec[0], "hello world");
321    /// ```
322    #[inline]
323    pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
324        if index < self.len as usize {
325            unsafe { Some(&mut *self.data.as_ptr().add(index)) }
326        } else {
327            None
328        }
329    }
330
331    /// Returns a reference to an element without bounds checking.
332    ///
333    /// # Safety
334    /// Calling this method with an out-of-bounds index is undefined behavior.
335    /// The caller must ensure that `index < self.len()`.
336    ///
337    /// # Arguments
338    /// * `index` - The index to access
339    ///
340    /// # Examples
341    ///
342    /// ```rust
343    /// # use qudit_core::LimitedSizeVec;
344    ///
345    /// let mut vec = LimitedSizeVec::new();
346    /// vec.push("hello");
347    ///
348    /// unsafe {
349    ///     assert_eq!(vec.get_unchecked(0), &"hello");
350    /// }
351    /// ```
352    #[inline]
353    pub unsafe fn get_unchecked(&self, index: usize) -> &T {
354        unsafe {
355            debug_assert!(
356                index < self.len as usize,
357                "index out of bounds: {} >= {}",
358                index,
359                self.len
360            );
361            &*self.data.as_ptr().add(index)
362        }
363    }
364
365    /// Returns a mutable reference to an element without bounds checking.
366    ///
367    /// # Safety
368    /// Calling this method with an out-of-bounds index is undefined behavior.
369    /// The caller must ensure that `index < self.len()`.
370    ///
371    /// # Arguments
372    /// * `index` - The index to access
373    ///
374    /// # Examples
375    ///
376    /// ```rust
377    /// # use qudit_core::LimitedSizeVec;
378    ///
379    /// let mut vec = LimitedSizeVec::new();
380    /// vec.push(String::from("hello"));
381    ///
382    /// unsafe {
383    ///     vec.get_mut_unchecked(0).push_str(" world");
384    /// }
385    /// assert_eq!(vec[0], "hello world");
386    /// ```
387    #[inline]
388    pub unsafe fn get_mut_unchecked(&mut self, index: usize) -> &mut T {
389        unsafe {
390            debug_assert!(
391                index < self.len as usize,
392                "index out of bounds: {} >= {}",
393                index,
394                self.len
395            );
396            &mut *self.data.as_ptr().add(index)
397        }
398    }
399
400    /// Removes the last element from the vector and returns it, or `None` if empty.
401    ///
402    /// # Examples
403    ///
404    /// ```rust
405    /// # use qudit_core::LimitedSizeVec;
406    ///
407    /// let mut vec = LimitedSizeVec::new();
408    /// vec.push(1);
409    /// vec.push(2);
410    ///
411    /// assert_eq!(vec.pop(), Some(2));
412    /// assert_eq!(vec.pop(), Some(1));
413    /// assert_eq!(vec.pop(), None);
414    /// ```
415    #[inline]
416    pub fn pop(&mut self) -> Option<T> {
417        if self.len > 0 {
418            self.len -= 1;
419            unsafe { Some(std::ptr::read(self.data.as_ptr().add(self.len as usize))) }
420        } else {
421            None
422        }
423    }
424
425    /// Removes and returns the element at position `index`, shifting all elements after it to the left.
426    ///
427    /// # Panics
428    /// Panics if `index` is out of bounds.
429    ///
430    /// # Examples
431    ///
432    /// ```rust
433    /// # use qudit_core::LimitedSizeVec;
434    ///
435    /// let mut vec = LimitedSizeVec::new();
436    /// vec.push("a");
437    /// vec.push("b");
438    /// vec.push("c");
439    ///
440    /// assert_eq!(vec.remove(1), "b");
441    /// assert_eq!(vec.as_slice(), ["a", "c"]);
442    /// ```
443    #[inline]
444    pub fn remove(&mut self, index: usize) -> T {
445        if index >= self.len as usize {
446            panic!(
447                "removal index (is {}) should be < len (is {})",
448                index, self.len
449            );
450        }
451
452        unsafe {
453            let ptr = self.data.as_ptr().add(index);
454            let ret = std::ptr::read(ptr);
455
456            // Shift elements left
457            let remaining = self.len as usize - index - 1;
458            if remaining > 0 {
459                std::ptr::copy(ptr.add(1), ptr, remaining);
460            }
461
462            self.len -= 1;
463            ret
464        }
465    }
466
467    /// Inserts an element at position `index`, shifting all elements after it to the right.
468    ///
469    /// # Panics
470    /// Panics if `index > len`.
471    ///
472    /// # Examples
473    ///
474    /// ```rust
475    /// # use qudit_core::LimitedSizeVec;
476    ///
477    /// let mut vec = LimitedSizeVec::new();
478    /// vec.push("a");
479    /// vec.push("c");
480    ///
481    /// vec.insert(1, "b");
482    /// assert_eq!(vec.as_slice(), ["a", "b", "c"]);
483    /// ```
484    #[inline]
485    pub fn insert(&mut self, index: usize, element: T) {
486        if index > self.len as usize {
487            panic!(
488                "insertion index (is {}) should be <= len (is {})",
489                index, self.len
490            );
491        }
492
493        if self.len >= self.capacity {
494            self.grow();
495        }
496
497        unsafe {
498            let ptr = self.data.as_ptr().add(index);
499
500            // Shift elements right
501            let remaining = self.len as usize - index;
502            if remaining > 0 {
503                std::ptr::copy(ptr, ptr.add(1), remaining);
504            }
505
506            std::ptr::write(ptr, element);
507            self.len += 1;
508        }
509    }
510
511    /// Shortens the vector, keeping the first `len` elements and dropping the rest.
512    ///
513    /// If `len` is greater than the vector's current length, this has no effect.
514    ///
515    /// # Examples
516    ///
517    /// ```rust
518    /// # use qudit_core::LimitedSizeVec;
519    ///
520    /// let mut vec = LimitedSizeVec::new();
521    /// vec.push(1);
522    /// vec.push(2);
523    /// vec.push(3);
524    /// vec.push(4);
525    ///
526    /// vec.truncate(2);
527    /// assert_eq!(vec.as_slice(), [1, 2]);
528    /// ```
529    #[inline]
530    pub fn truncate(&mut self, len: usize) {
531        if len < self.len as usize {
532            let new_len = len as u32;
533            if std::mem::needs_drop::<T>() {
534                unsafe {
535                    for i in new_len..self.len {
536                        std::ptr::drop_in_place(self.data.as_ptr().add(i as usize));
537                    }
538                }
539            }
540            self.len = new_len;
541        }
542    }
543
544    /// Resizes the vector to the given length.
545    ///
546    /// If `new_len` is greater than `len`, the vector is extended with clones of `value`.
547    /// If `new_len` is less than `len`, the vector is truncated.
548    ///
549    /// # Examples
550    ///
551    /// ```rust
552    /// # use qudit_core::LimitedSizeVec;
553    ///
554    /// let mut vec = LimitedSizeVec::new();
555    /// vec.push(1);
556    ///
557    /// vec.resize(3, 0);
558    /// assert_eq!(vec.as_slice(), [1, 0, 0]);
559    ///
560    /// vec.resize(1, 2);
561    /// assert_eq!(vec.as_slice(), [1]);
562    /// ```
563    #[inline]
564    pub fn resize(&mut self, new_len: usize, value: T)
565    where
566        T: Clone,
567    {
568        let current_len = self.len as usize;
569        if new_len > current_len {
570            self.reserve(new_len - current_len);
571            for _ in current_len..new_len {
572                self.push(value.clone());
573            }
574        } else {
575            self.truncate(new_len);
576        }
577    }
578
579    /// Extends the vector by cloning elements from a slice.
580    ///
581    /// # Examples
582    ///
583    /// ```rust
584    /// # use qudit_core::LimitedSizeVec;
585    ///
586    /// let mut vec = LimitedSizeVec::new();
587    /// vec.push(1);
588    ///
589    /// vec.extend_from_slice(&[2, 3, 4]);
590    /// assert_eq!(vec.as_slice(), [1, 2, 3, 4]);
591    /// ```
592    #[inline]
593    pub fn extend_from_slice(&mut self, other: &[T])
594    where
595        T: Clone,
596    {
597        self.reserve(other.len());
598        for item in other {
599            self.push(item.clone());
600        }
601    }
602
603    /// Reserves capacity for at least `additional` more elements.
604    ///
605    /// Does nothing if the capacity is already sufficient.
606    ///
607    /// # Examples
608    ///
609    /// ```rust
610    /// # use qudit_core::LimitedSizeVec;
611    ///
612    /// let mut vec: LimitedSizeVec<usize> = LimitedSizeVec::new();
613    /// vec.reserve(100);
614    /// assert!(vec.capacity() >= 100);
615    /// ```
616    #[inline]
617    pub fn reserve(&mut self, additional: usize) {
618        let required = self.len as usize + additional;
619        if required > self.capacity as usize {
620            self.grow_to_capacity(required.max(self.capacity as usize * 2) as u32);
621        }
622    }
623
624    /// Appends an element without checking capacity.
625    ///
626    /// # Safety
627    /// The caller must ensure that `self.len < self.capacity`.
628    ///
629    /// # Examples
630    ///
631    /// ```rust
632    /// # use qudit_core::LimitedSizeVec;
633    ///
634    /// let mut vec = LimitedSizeVec::new_with_capacity(10);
635    /// unsafe {
636    ///     vec.push_unchecked(42);
637    /// }
638    /// assert_eq!(vec[0], 42);
639    /// ```
640    #[inline]
641    pub unsafe fn push_unchecked(&mut self, value: T) {
642        unsafe {
643            debug_assert!(
644                self.len < self.capacity,
645                "capacity exceeded: {} >= {}",
646                self.len,
647                self.capacity
648            );
649            self.data.as_ptr().add(self.len as usize).write(value);
650            self.len += 1;
651        }
652    }
653
654    /// Clears the vector, removing all elements but keeping allocated capacity.
655    ///
656    /// # Examples
657    ///
658    /// ```rust
659    /// # use qudit_core::LimitedSizeVec;
660    ///
661    /// let mut vec = LimitedSizeVec::new();
662    /// vec.push(1);
663    /// vec.push(2);
664    ///
665    /// let old_capacity = vec.capacity();
666    /// vec.clear();
667    ///
668    /// assert_eq!(vec.len(), 0);
669    /// assert_eq!(vec.capacity(), old_capacity);
670    /// ```
671    #[inline]
672    pub fn clear(&mut self) {
673        if self.len > 0 {
674            if std::mem::needs_drop::<T>() {
675                for i in 0..self.len {
676                    unsafe {
677                        std::ptr::drop_in_place(self.data.as_ptr().add(i as usize));
678                    }
679                }
680            }
681            self.len = 0;
682        }
683    }
684
685    /// Sorts the vector in-place using the natural ordering of elements.
686    ///
687    /// This method requires that `T` implements `Ord`.
688    ///
689    /// # Examples
690    ///
691    /// ```rust
692    /// # use qudit_core::LimitedSizeVec;
693    ///
694    /// let mut vec = LimitedSizeVec::new();
695    /// vec.push(3);
696    /// vec.push(1);
697    /// vec.push(2);
698    ///
699    /// vec.sort();
700    /// assert_eq!(vec.as_slice(), [1, 2, 3]);
701    /// ```
702    #[inline]
703    pub fn sort(&mut self)
704    where
705        T: Ord,
706    {
707        let slice = self.as_slice_mut();
708        slice.sort();
709    }
710
711    /// Takes ownership of the vector's contents, leaving the original empty.
712    ///
713    /// This is a zero-cost operation that transfers ownership without cloning.
714    ///
715    /// # Examples
716    ///
717    /// ```rust
718    /// # use qudit_core::LimitedSizeVec;
719    ///
720    /// let mut vec1 = LimitedSizeVec::new();
721    /// vec1.push(1);
722    /// vec1.push(2);
723    ///
724    /// let vec2 = vec1.take();
725    /// assert_eq!(vec1.len(), 0);
726    /// assert_eq!(vec2.len(), 2);
727    /// ```
728    #[inline]
729    pub fn take(&mut self) -> Self {
730        let cap = self.capacity;
731        let len = self.len;
732        let ptr = self.data;
733
734        // Reset self to valid empty state
735        self.data = NonNull::dangling();
736        self.len = 0;
737        self.capacity = 0;
738
739        Self {
740            data: ptr,
741            len,
742            capacity: cap,
743        }
744    }
745
746    /// Creates a new vector by cloning this one.
747    ///
748    /// This method is equivalent to `clone()` but provides a more explicit name.
749    ///
750    /// # Examples
751    ///
752    /// ```rust
753    /// # use qudit_core::LimitedSizeVec;
754    ///
755    /// let mut vec1 = LimitedSizeVec::new();
756    /// vec1.push("hello".to_string());
757    ///
758    /// let vec2 = vec1.to_owned();
759    /// assert_eq!(vec1.len(), 1);
760    /// assert_eq!(vec2.len(), 1);
761    /// ```
762    #[inline]
763    pub fn to_owned(&self) -> Self
764    where
765        T: Clone,
766    {
767        self.clone()
768    }
769
770    /// Returns the vector's contents as a slice.
771    ///
772    /// # Examples
773    ///
774    /// ```rust
775    /// # use qudit_core::LimitedSizeVec;
776    ///
777    /// let mut vec = LimitedSizeVec::new();
778    /// vec.push(1);
779    /// vec.push(2);
780    ///
781    /// let slice = vec.as_slice();
782    /// assert_eq!(slice, [1, 2]);
783    /// ```
784    #[inline(always)]
785    pub fn as_slice(&self) -> &[T] {
786        unsafe { std::slice::from_raw_parts(self.data.as_ptr(), self.len as usize) }
787    }
788
789    /// Returns the vector's contents as a mutable slice.
790    ///
791    /// # Examples
792    ///
793    /// ```rust
794    /// # use qudit_core::LimitedSizeVec;
795    ///
796    /// let mut vec = LimitedSizeVec::new();
797    /// vec.push(1);
798    /// vec.push(2);
799    ///
800    /// let slice = vec.as_slice_mut();
801    /// slice[0] = 10;
802    /// assert_eq!(vec[0], 10);
803    /// ```
804    #[inline(always)]
805    pub fn as_slice_mut(&mut self) -> &mut [T] {
806        unsafe { std::slice::from_raw_parts_mut(self.data.as_ptr(), self.len as usize) }
807    }
808}
809
810impl<T: Clone> Clone for LimitedSizeVec<T> {
811    /// Creates a clone of the vector.
812    ///
813    /// All elements are cloned individually, and the new vector will have
814    /// the same capacity as the original.
815    ///
816    /// # Examples
817    ///
818    /// ```rust
819    /// # use qudit_core::LimitedSizeVec;
820    ///
821    /// let mut vec1 = LimitedSizeVec::new();
822    /// vec1.push("hello".to_string());
823    ///
824    /// let vec2 = vec1.clone();
825    /// assert_eq!(vec1.len(), vec2.len());
826    /// assert_eq!(vec1[0], vec2[0]);
827    /// ```
828    fn clone(&self) -> Self {
829        if self.len == 0 {
830            return Self::new_with_capacity(self.capacity);
831        }
832
833        let mut new_vec = Self::new_with_capacity(self.capacity);
834
835        // Clone each element individually for safety
836        for i in 0..self.len {
837            unsafe {
838                let item = &*self.data.as_ptr().add(i as usize);
839                new_vec.push(item.clone());
840            }
841        }
842
843        new_vec
844    }
845}
846
847impl<T> Default for LimitedSizeVec<T> {
848    /// Creates an empty vector with default capacity.
849    #[inline]
850    fn default() -> Self {
851        Self::new()
852    }
853}
854
855impl<T: fmt::Debug> fmt::Debug for LimitedSizeVec<T> {
856    /// Formats the vector for debugging output.
857    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
858        f.debug_list().entries(self.as_slice().iter()).finish()
859    }
860}
861
862impl<T: PartialEq> PartialEq for LimitedSizeVec<T> {
863    fn eq(&self, other: &Self) -> bool {
864        if self.len != other.len {
865            return false;
866        }
867        self.as_slice().eq(other.as_slice())
868    }
869}
870
871impl<T: Eq> Eq for LimitedSizeVec<T> {}
872
873impl<T: Hash> Hash for LimitedSizeVec<T> {
874    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
875        self.len.hash(state);
876        self.as_slice().hash(state);
877    }
878}
879
880impl<T> std::ops::Deref for LimitedSizeVec<T> {
881    type Target = [T];
882
883    #[inline(always)]
884    fn deref(&self) -> &Self::Target {
885        self.as_slice()
886    }
887}
888
889impl<T> std::ops::DerefMut for LimitedSizeVec<T> {
890    #[inline(always)]
891    fn deref_mut(&mut self) -> &mut Self::Target {
892        self.as_slice_mut()
893    }
894}
895
896impl<T> std::ops::Index<usize> for LimitedSizeVec<T> {
897    type Output = T;
898
899    #[inline(always)]
900    fn index(&self, index: usize) -> &Self::Output {
901        &self.as_slice()[index]
902    }
903}
904
905impl<T> std::ops::IndexMut<usize> for LimitedSizeVec<T> {
906    #[inline(always)]
907    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
908        &mut self.as_slice_mut()[index]
909    }
910}
911
912impl<T> AsRef<[T]> for LimitedSizeVec<T> {
913    #[inline(always)]
914    fn as_ref(&self) -> &[T] {
915        self.as_slice()
916    }
917}
918
919impl<T> AsMut<[T]> for LimitedSizeVec<T> {
920    #[inline(always)]
921    fn as_mut(&mut self) -> &mut [T] {
922        self.as_slice_mut()
923    }
924}
925
926impl<T> From<Vec<T>> for LimitedSizeVec<T> {
927    /// Converts a `Vec<T>` into a `LimitedSizeVec<T>`.
928    ///
929    fn from(vec: Vec<T>) -> Self {
930        let len = vec.len();
931        let capacity = vec.capacity();
932
933        if capacity > u32::MAX as usize {
934            panic!("Vector capacity exceeds maximum allowed for LimitedSizeVec (u32::MAX)");
935        }
936
937        // Prevent `vec` from dropping its contents
938        let mut temp_vec = std::mem::ManuallyDrop::new(vec);
939
940        // Get raw parts
941        let ptr = temp_vec.as_mut_ptr();
942        let len_u32 = len as u32; // Assuming len fits, as capacity is checked
943        let cap_u32 = capacity as u32;
944
945        LimitedSizeVec {
946            data: NonNull::new(ptr).unwrap_or_else(|| Self::allocation_failed_panic()),
947            len: len_u32,
948            capacity: cap_u32,
949        }
950    }
951}
952
953impl<T: Clone> From<&[T]> for LimitedSizeVec<T> {
954    /// Converts a slice into a `LimitedSizeVec<T>` by cloning elements.
955    fn from(slice: &[T]) -> Self {
956        let mut limited_vec =
957            Self::new_with_capacity(slice.len().max(DEFAULT_CAPACITY as usize) as u32);
958        for item in slice {
959            limited_vec.push(item.clone());
960        }
961        limited_vec
962    }
963}
964
965impl<T: Clone> From<&Vec<T>> for LimitedSizeVec<T> {
966    /// Converts a `&Vec<T>` into a `LimitedSizeVec<T>` by cloning elements.
967    #[inline]
968    fn from(vec: &Vec<T>) -> Self {
969        Self::from(vec.as_slice())
970    }
971}
972
973impl<T> FromIterator<T> for LimitedSizeVec<T> {
974    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
975        let iter = iter.into_iter();
976        let (lower_bound, _) = iter.size_hint();
977        let mut vec =
978            LimitedSizeVec::new_with_capacity(lower_bound.max(DEFAULT_CAPACITY as usize) as u32);
979        for item in iter {
980            vec.push(item);
981        }
982        vec
983    }
984}
985
986impl<T> From<LimitedSizeVec<T>> for Vec<T> {
987    /// Converts a `LimitedSizeVec<T>` into a `Vec<T>` without copying elements.
988    ///
989    /// This is a zero-cost conversion that transfers ownership of the underlying buffer.
990    fn from(mut limited_vec: LimitedSizeVec<T>) -> Self {
991        let len = limited_vec.len();
992        let capacity = limited_vec.capacity();
993        let ptr = limited_vec.data.as_ptr();
994
995        // Prevent limited_vec from dropping the memory by resetting it
996        limited_vec.data = NonNull::dangling();
997        limited_vec.len = 0;
998        limited_vec.capacity = 0;
999
1000        unsafe { Self::from_raw_parts(ptr, len, capacity) }
1001    }
1002}
1003
1004/// An iterator that moves out of a `LimitedSizeVec`.
1005pub struct IntoIter<T> {
1006    data: NonNull<T>,
1007    start: *const T,
1008    end: *const T,
1009    capacity: u32,
1010}
1011
1012impl<T> Iterator for IntoIter<T> {
1013    type Item = T;
1014
1015    #[inline]
1016    fn next(&mut self) -> Option<Self::Item> {
1017        if self.start == self.end {
1018            None
1019        } else {
1020            unsafe {
1021                let current = self.start;
1022                self.start = self.start.add(1);
1023                Some(std::ptr::read(current))
1024            }
1025        }
1026    }
1027
1028    #[inline]
1029    fn size_hint(&self) -> (usize, Option<usize>) {
1030        let len = unsafe { self.end.offset_from(self.start) } as usize;
1031        (len, Some(len))
1032    }
1033}
1034
1035impl<T> DoubleEndedIterator for IntoIter<T> {
1036    #[inline]
1037    fn next_back(&mut self) -> Option<Self::Item> {
1038        if self.start == self.end {
1039            None
1040        } else {
1041            unsafe {
1042                self.end = self.end.sub(1);
1043                Some(std::ptr::read(self.end))
1044            }
1045        }
1046    }
1047}
1048
1049impl<T> ExactSizeIterator for IntoIter<T> {}
1050
1051impl<T> Drop for IntoIter<T> {
1052    fn drop(&mut self) {
1053        // Drop any remaining elements
1054        for _ in &mut *self {}
1055
1056        // Deallocate memory if we have capacity
1057        if self.capacity > 0 {
1058            unsafe {
1059                dealloc(
1060                    self.data.as_ptr() as *mut u8,
1061                    Layout::array::<T>(self.capacity as usize).unwrap(),
1062                );
1063            }
1064        }
1065    }
1066}
1067
1068impl<T> IntoIterator for LimitedSizeVec<T> {
1069    type Item = T;
1070    type IntoIter = IntoIter<T>;
1071
1072    /// Creates a consuming iterator, that is, one that moves each value out of
1073    /// the vector (from start to end). The vector cannot be used after calling this.
1074    ///
1075    /// # Examples
1076    ///
1077    /// ```rust
1078    /// # use qudit_core::LimitedSizeVec;
1079    ///
1080    /// let mut vec = LimitedSizeVec::new();
1081    /// vec.push(1);
1082    /// vec.push(2);
1083    /// vec.push(3);
1084    ///
1085    /// let mut iterator = vec.into_iter();
1086    /// assert_eq!(iterator.next(), Some(1));
1087    /// assert_eq!(iterator.next(), Some(2));
1088    /// assert_eq!(iterator.next(), Some(3));
1089    /// assert_eq!(iterator.next(), None);
1090    /// ```
1091    #[inline]
1092    fn into_iter(mut self) -> Self::IntoIter {
1093        let ptr = self.data.as_ptr();
1094        let len = self.len as usize;
1095        let capacity = self.capacity;
1096
1097        // Prevent the vector from being dropped
1098        self.data = NonNull::dangling();
1099        self.len = 0;
1100        self.capacity = 0;
1101
1102        IntoIter {
1103            data: NonNull::new(ptr).unwrap(),
1104            start: ptr,
1105            end: unsafe { ptr.add(len) },
1106            capacity,
1107        }
1108    }
1109}
1110
1111impl<'a, T> IntoIterator for &'a LimitedSizeVec<T> {
1112    type Item = &'a T;
1113    type IntoIter = std::slice::Iter<'a, T>;
1114
1115    /// Creates an iterator over references to the elements of the vector.
1116    ///
1117    /// # Examples
1118    ///
1119    /// ```rust
1120    /// # use qudit_core::LimitedSizeVec;
1121    ///
1122    /// let mut vec = LimitedSizeVec::new();
1123    /// vec.push(1);
1124    /// vec.push(2);
1125    ///
1126    /// for item in &vec {
1127    ///     println!("{}", item);
1128    /// }
1129    /// ```
1130    #[inline]
1131    fn into_iter(self) -> Self::IntoIter {
1132        self.as_slice().iter()
1133    }
1134}
1135
1136impl<'a, T> IntoIterator for &'a mut LimitedSizeVec<T> {
1137    type Item = &'a mut T;
1138    type IntoIter = std::slice::IterMut<'a, T>;
1139
1140    /// Creates an iterator over mutable references to the elements of the vector.
1141    ///
1142    /// # Examples
1143    ///
1144    /// ```rust
1145    /// # use qudit_core::LimitedSizeVec;
1146    ///
1147    /// let mut vec = LimitedSizeVec::new();
1148    /// vec.push(1);
1149    /// vec.push(2);
1150    ///
1151    /// for item in &mut vec {
1152    ///     *item *= 2;
1153    /// }
1154    /// assert_eq!(vec.as_slice(), [2, 4]);
1155    /// ```
1156    #[inline]
1157    fn into_iter(self) -> Self::IntoIter {
1158        self.as_slice_mut().iter_mut()
1159    }
1160}
1161// Safety: LimitedSizeVec<T> is Send if T is Send
1162unsafe impl<T: Send> Send for LimitedSizeVec<T> {}
1163
1164// Safety: LimitedSizeVec<T> is Sync if T is Sync
1165unsafe impl<T: Sync> Sync for LimitedSizeVec<T> {}
1166
1167impl<T> Drop for LimitedSizeVec<T> {
1168    /// Cleans up the vector's memory and drops all elements.
1169    fn drop(&mut self) {
1170        if self.capacity > 0 {
1171            // Drop all elements
1172            for i in 0..self.len {
1173                unsafe {
1174                    std::ptr::drop_in_place(self.data.as_ptr().add(i as usize));
1175                }
1176            }
1177
1178            // Deallocate memory
1179            unsafe {
1180                dealloc(
1181                    self.data.as_ptr() as *mut u8,
1182                    Layout::array::<T>(self.capacity as usize).unwrap(),
1183                );
1184            }
1185        }
1186    }
1187}
1188
1189#[cfg(test)]
1190mod tests {
1191    use super::*;
1192
1193    #[test]
1194    fn test_new_vector_creation() {
1195        let vec: LimitedSizeVec<i32> = LimitedSizeVec::new();
1196        assert_eq!(vec.len(), 0);
1197        assert_eq!(vec.capacity(), DEFAULT_CAPACITY as usize);
1198        assert!(vec.is_empty());
1199    }
1200
1201    #[test]
1202    fn test_vector_with_custom_capacity() {
1203        let vec: LimitedSizeVec<i32> = LimitedSizeVec::new_with_capacity(50);
1204        assert_eq!(vec.len(), 0);
1205        assert_eq!(vec.capacity(), 50);
1206        assert!(vec.is_empty());
1207    }
1208
1209    #[test]
1210    #[should_panic(expected = "Cannot create vector with zero capacity")]
1211    fn test_zero_capacity_panics() {
1212        LimitedSizeVec::<i32>::new_with_capacity(0);
1213    }
1214
1215    #[test]
1216    fn test_push_and_access_elements() {
1217        let mut vec = LimitedSizeVec::new();
1218        vec.push(1);
1219        vec.push(2);
1220        vec.push(3);
1221
1222        assert_eq!(vec.len(), 3);
1223        assert!(!vec.is_empty());
1224        assert_eq!(vec[0], 1);
1225        assert_eq!(vec[1], 2);
1226        assert_eq!(vec[2], 3);
1227    }
1228
1229    #[test]
1230    fn test_get_method_bounds_checking() {
1231        let mut vec = LimitedSizeVec::new();
1232        vec.push("hello");
1233        vec.push("world");
1234
1235        assert_eq!(vec.get(0), Some(&"hello"));
1236        assert_eq!(vec.get(1), Some(&"world"));
1237        assert_eq!(vec.get(2), None);
1238        assert_eq!(vec.get(100), None);
1239    }
1240
1241    #[test]
1242    fn test_get_mut_method() {
1243        let mut vec = LimitedSizeVec::new();
1244        vec.push(String::from("hello"));
1245
1246        if let Some(element) = vec.get_mut(0) {
1247            element.push_str(" world");
1248        }
1249
1250        assert_eq!(vec[0], "hello world");
1251        assert_eq!(vec.get_mut(1), None);
1252    }
1253
1254    #[test]
1255    fn test_capacity_growth_on_push() {
1256        let mut vec = LimitedSizeVec::new_with_capacity(2);
1257        assert_eq!(vec.capacity(), 2);
1258
1259        vec.push(1);
1260        vec.push(2);
1261        assert_eq!(vec.capacity(), 2);
1262
1263        // This should trigger growth
1264        vec.push(3);
1265        assert_eq!(vec.capacity(), 4);
1266        assert_eq!(vec.len(), 3);
1267    }
1268
1269    #[test]
1270    fn test_as_slice_operations() {
1271        let mut vec = LimitedSizeVec::new();
1272        vec.push(3);
1273        vec.push(1);
1274        vec.push(4);
1275        vec.push(1);
1276        vec.push(5);
1277
1278        let slice = vec.as_slice();
1279        assert_eq!(slice, [3, 1, 4, 1, 5]);
1280
1281        let mut_slice = vec.as_slice_mut();
1282        mut_slice[0] = 10;
1283        assert_eq!(vec[0], 10);
1284    }
1285
1286    #[test]
1287    fn test_sort_method() {
1288        let mut vec = LimitedSizeVec::new();
1289        vec.push(3);
1290        vec.push(1);
1291        vec.push(4);
1292        vec.push(1);
1293        vec.push(5);
1294
1295        vec.sort();
1296        assert_eq!(vec.as_slice(), [1, 1, 3, 4, 5]);
1297    }
1298
1299    #[test]
1300    fn test_clear_method() {
1301        let mut vec = LimitedSizeVec::new();
1302        vec.push(1);
1303        vec.push(2);
1304        vec.push(3);
1305
1306        let old_capacity = vec.capacity();
1307        vec.clear();
1308
1309        assert_eq!(vec.len(), 0);
1310        assert!(vec.is_empty());
1311        assert_eq!(vec.capacity(), old_capacity); // Capacity preserved
1312    }
1313
1314    #[test]
1315    fn test_take_method() {
1316        let mut vec1 = LimitedSizeVec::new();
1317        vec1.push("hello");
1318        vec1.push("world");
1319
1320        let vec2 = vec1.take();
1321
1322        assert_eq!(vec1.len(), 0);
1323        assert!(vec1.is_empty());
1324        assert_eq!(vec2.len(), 2);
1325        assert_eq!(vec2[0], "hello");
1326        assert_eq!(vec2[1], "world");
1327    }
1328
1329    #[test]
1330    fn test_clone_implementation() {
1331        let mut vec1 = LimitedSizeVec::new();
1332        vec1.push(String::from("hello"));
1333        vec1.push(String::from("world"));
1334
1335        let vec2 = vec1.clone();
1336
1337        assert_eq!(vec1.len(), vec2.len());
1338        assert_eq!(vec1.capacity(), vec2.capacity());
1339        assert_eq!(vec1[0], vec2[0]);
1340        assert_eq!(vec1[1], vec2[1]);
1341
1342        // Verify they're independent
1343        drop(vec1);
1344        assert_eq!(vec2.len(), 2);
1345    }
1346
1347    #[test]
1348    fn test_to_owned_method() {
1349        let mut vec1 = LimitedSizeVec::new();
1350        vec1.push("test".to_string());
1351
1352        let vec2 = vec1.to_owned();
1353        assert_eq!(vec1.len(), vec2.len());
1354        assert_eq!(vec1[0], vec2[0]);
1355    }
1356
1357    #[test]
1358    fn test_deref_operations() {
1359        let mut vec = LimitedSizeVec::new();
1360        vec.push(1);
1361        vec.push(2);
1362        vec.push(3);
1363
1364        // Test Deref to slice
1365        let slice: &[i32] = &vec;
1366        assert_eq!(slice.len(), 3);
1367        assert_eq!(slice[0], 1);
1368
1369        // Test DerefMut to slice
1370        let slice_mut: &mut [i32] = &mut vec;
1371        slice_mut[0] = 10;
1372        assert_eq!(vec[0], 10);
1373    }
1374
1375    #[test]
1376    fn test_from_vec_conversion() {
1377        let std_vec = vec![1, 2, 3, 4, 5];
1378        let limited_vec: LimitedSizeVec<i32> = LimitedSizeVec::from(std_vec);
1379
1380        assert_eq!(limited_vec.len(), 5);
1381        assert_eq!(limited_vec.as_slice(), [1, 2, 3, 4, 5]);
1382        assert!(limited_vec.capacity() >= 5);
1383    }
1384
1385    #[test]
1386    fn test_from_slice_conversion() {
1387        let slice = [1, 2, 3];
1388        let limited_vec: LimitedSizeVec<i32> = LimitedSizeVec::from(&slice[..]);
1389
1390        assert_eq!(limited_vec.len(), 3);
1391        assert_eq!(limited_vec.as_slice(), [1, 2, 3]);
1392    }
1393
1394    #[test]
1395    fn test_to_vec_conversion() {
1396        let mut limited_vec = LimitedSizeVec::new();
1397        limited_vec.push(1);
1398        limited_vec.push(2);
1399        limited_vec.push(3);
1400
1401        let std_vec: Vec<i32> = Vec::from(limited_vec);
1402        assert_eq!(std_vec, [1, 2, 3]);
1403    }
1404
1405    #[test]
1406    fn test_as_ref_and_as_mut() {
1407        let mut vec = LimitedSizeVec::new();
1408        vec.push("hello");
1409        vec.push("world");
1410
1411        let slice_ref: &[&str] = vec.as_ref();
1412        assert_eq!(slice_ref, ["hello", "world"]);
1413
1414        let slice_mut: &mut [&str] = vec.as_mut();
1415        slice_mut[0] = "goodbye";
1416        assert_eq!(vec[0], "goodbye");
1417    }
1418
1419    #[test]
1420    fn test_debug_formatting() {
1421        let mut vec = LimitedSizeVec::new();
1422        vec.push(1);
1423        vec.push(2);
1424
1425        let debug_str = format!("{:?}", vec);
1426        assert_eq!(debug_str, "[1, 2]");
1427    }
1428
1429    #[test]
1430    fn test_empty_vector_operations() {
1431        let vec: LimitedSizeVec<i32> = LimitedSizeVec::new();
1432        assert_eq!(vec.len(), 0);
1433        assert!(vec.is_empty());
1434        assert_eq!(vec.get(0), None);
1435    }
1436
1437    #[test]
1438    fn test_large_capacity_vector() {
1439        let vec: LimitedSizeVec<u8> = LimitedSizeVec::new_with_capacity(1000);
1440        assert_eq!(vec.capacity(), 1000);
1441        assert_eq!(vec.len(), 0);
1442    }
1443
1444    #[test]
1445    fn test_drop_behavior() {
1446        use std::rc::Rc;
1447
1448        let item = Rc::new("test");
1449        assert_eq!(Rc::strong_count(&item), 1);
1450
1451        {
1452            let mut vec = LimitedSizeVec::new();
1453            vec.push(item.clone());
1454            assert_eq!(Rc::strong_count(&item), 2);
1455        } // vec is dropped here
1456
1457        assert_eq!(Rc::strong_count(&item), 1);
1458    }
1459
1460    #[test]
1461    fn test_pop_method() {
1462        let mut vec = LimitedSizeVec::new();
1463        assert_eq!(vec.pop(), None);
1464
1465        vec.push(1);
1466        vec.push(2);
1467        vec.push(3);
1468
1469        assert_eq!(vec.pop(), Some(3));
1470        assert_eq!(vec.len(), 2);
1471        assert_eq!(vec.pop(), Some(2));
1472        assert_eq!(vec.pop(), Some(1));
1473        assert_eq!(vec.pop(), None);
1474        assert_eq!(vec.len(), 0);
1475    }
1476
1477    #[test]
1478    fn test_remove_method() {
1479        let mut vec = LimitedSizeVec::new();
1480        vec.push("a");
1481        vec.push("b");
1482        vec.push("c");
1483        vec.push("d");
1484
1485        // Remove from middle
1486        assert_eq!(vec.remove(1), "b");
1487        assert_eq!(vec.as_slice(), ["a", "c", "d"]);
1488
1489        // Remove from end
1490        assert_eq!(vec.remove(2), "d");
1491        assert_eq!(vec.as_slice(), ["a", "c"]);
1492
1493        // Remove from start
1494        assert_eq!(vec.remove(0), "a");
1495        assert_eq!(vec.as_slice(), ["c"]);
1496    }
1497
1498    #[test]
1499    #[should_panic(expected = "removal index (is 5) should be < len (is 2)")]
1500    fn test_remove_out_of_bounds() {
1501        let mut vec = LimitedSizeVec::new();
1502        vec.push(1);
1503        vec.push(2);
1504        vec.remove(5);
1505    }
1506
1507    #[test]
1508    fn test_insert_method() {
1509        let mut vec = LimitedSizeVec::new();
1510        vec.push("a");
1511        vec.push("c");
1512
1513        // Insert in middle
1514        vec.insert(1, "b");
1515        assert_eq!(vec.as_slice(), ["a", "b", "c"]);
1516
1517        // Insert at beginning
1518        vec.insert(0, "start");
1519        assert_eq!(vec.as_slice(), ["start", "a", "b", "c"]);
1520
1521        // Insert at end
1522        vec.insert(vec.len(), "end");
1523        assert_eq!(vec.as_slice(), ["start", "a", "b", "c", "end"]);
1524    }
1525
1526    #[test]
1527    #[should_panic(expected = "insertion index (is 5) should be <= len (is 2)")]
1528    fn test_insert_out_of_bounds() {
1529        let mut vec = LimitedSizeVec::new();
1530        vec.push(1);
1531        vec.push(2);
1532        vec.insert(5, 3);
1533    }
1534
1535    #[test]
1536    fn test_truncate_method() {
1537        let mut vec = LimitedSizeVec::new();
1538        vec.push(1);
1539        vec.push(2);
1540        vec.push(3);
1541        vec.push(4);
1542        vec.push(5);
1543
1544        let old_capacity = vec.capacity();
1545        vec.truncate(3);
1546
1547        assert_eq!(vec.len(), 3);
1548        assert_eq!(vec.as_slice(), [1, 2, 3]);
1549        assert_eq!(vec.capacity(), old_capacity); // Capacity preserved
1550
1551        // Truncate to 0
1552        vec.truncate(0);
1553        assert_eq!(vec.len(), 0);
1554        assert!(vec.is_empty());
1555
1556        // Truncate larger than length should do nothing
1557        vec.push(10);
1558        vec.truncate(10);
1559        assert_eq!(vec.len(), 1);
1560        assert_eq!(vec[0], 10);
1561    }
1562
1563    #[test]
1564    fn test_resize_method() {
1565        let mut vec = LimitedSizeVec::new();
1566        vec.push(1);
1567
1568        // Resize up
1569        vec.resize(4, 42);
1570        assert_eq!(vec.as_slice(), [1, 42, 42, 42]);
1571
1572        // Resize down
1573        vec.resize(2, 0);
1574        assert_eq!(vec.as_slice(), [1, 42]);
1575
1576        // Resize to same size
1577        vec.resize(2, 100);
1578        assert_eq!(vec.as_slice(), [1, 42]);
1579    }
1580
1581    #[test]
1582    fn test_extend_from_slice() {
1583        let mut vec = LimitedSizeVec::new();
1584        vec.push(1);
1585
1586        vec.extend_from_slice(&[2, 3, 4]);
1587        assert_eq!(vec.as_slice(), [1, 2, 3, 4]);
1588
1589        vec.extend_from_slice(&[]);
1590        assert_eq!(vec.as_slice(), [1, 2, 3, 4]);
1591
1592        vec.extend_from_slice(&[5, 6]);
1593        assert_eq!(vec.as_slice(), [1, 2, 3, 4, 5, 6]);
1594    }
1595
1596    #[test]
1597    fn test_reserve_method() {
1598        let mut vec = LimitedSizeVec::new();
1599        assert_eq!(vec.capacity(), 8);
1600
1601        vec.reserve(50);
1602        assert!(vec.capacity() >= 50);
1603
1604        let old_capacity = vec.capacity();
1605        vec.reserve(10); // Less than current, should do nothing
1606        assert_eq!(vec.capacity(), old_capacity);
1607
1608        // Test with existing elements
1609        vec.push(1);
1610        vec.push(2);
1611        vec.reserve(100);
1612        assert!(vec.capacity() >= 100);
1613        assert_eq!(vec.as_slice(), [1, 2]);
1614    }
1615
1616    #[test]
1617    fn test_push_unchecked() {
1618        let mut vec = LimitedSizeVec::new_with_capacity(10);
1619
1620        unsafe {
1621            vec.push_unchecked(1);
1622            vec.push_unchecked(2);
1623            vec.push_unchecked(3);
1624        }
1625
1626        assert_eq!(vec.len(), 3);
1627        assert_eq!(vec.as_slice(), [1, 2, 3]);
1628    }
1629
1630    #[test]
1631    fn test_get_unchecked_methods() {
1632        let mut vec = LimitedSizeVec::new();
1633        vec.push(String::from("hello"));
1634        vec.push(String::from("world"));
1635
1636        unsafe {
1637            assert_eq!(vec.get_unchecked(0), &"hello");
1638            assert_eq!(vec.get_unchecked(1), &"world");
1639
1640            vec.get_mut_unchecked(0).push_str(" there");
1641            assert_eq!(vec.get_unchecked(0), &"hello there");
1642        }
1643    }
1644
1645    #[test]
1646    fn test_from_iterator() {
1647        let iter = 0..5;
1648        let vec: LimitedSizeVec<i32> = iter.collect();
1649        assert_eq!(vec.len(), 5);
1650        assert_eq!(vec.as_slice(), [0, 1, 2, 3, 4]);
1651
1652        let empty_iter: std::vec::IntoIter<i32> = Vec::new().into_iter();
1653        let empty_vec: LimitedSizeVec<i32> = empty_iter.collect();
1654        assert_eq!(empty_vec.len(), 0);
1655    }
1656
1657    #[test]
1658    fn test_from_iterator_with_strings() {
1659        let iter = vec!["a".to_string(), "b".to_string(), "c".to_string()].into_iter();
1660        let vec: LimitedSizeVec<String> = iter.collect();
1661        assert_eq!(vec.len(), 3);
1662        assert_eq!(vec.as_slice(), ["a", "b", "c"]);
1663    }
1664
1665    #[test]
1666    fn test_into_iterator() {
1667        let mut vec = LimitedSizeVec::new();
1668        vec.push(1);
1669        vec.push(2);
1670        vec.push(3);
1671
1672        let collected: Vec<i32> = vec.into_iter().collect();
1673        assert_eq!(collected, [1, 2, 3]);
1674    }
1675
1676    #[test]
1677    fn test_iterator_double_ended() {
1678        let mut vec = LimitedSizeVec::new();
1679        vec.push(1);
1680        vec.push(2);
1681        vec.push(3);
1682
1683        let mut iter = vec.into_iter();
1684        assert_eq!(iter.next(), Some(1));
1685        assert_eq!(iter.next_back(), Some(3));
1686        assert_eq!(iter.next(), Some(2));
1687        assert_eq!(iter.next(), None);
1688        assert_eq!(iter.next_back(), None);
1689    }
1690
1691    #[test]
1692    fn test_borrowed_iterator() {
1693        let mut vec = LimitedSizeVec::new();
1694        vec.push(1);
1695        vec.push(2);
1696        vec.push(3);
1697
1698        let sum: i32 = (&vec).into_iter().sum();
1699        assert_eq!(sum, 6);
1700
1701        // Vector should still exist
1702        assert_eq!(vec.len(), 3);
1703    }
1704
1705    #[test]
1706    fn test_mutable_borrowed_iterator() {
1707        let mut vec = LimitedSizeVec::new();
1708        vec.push(1);
1709        vec.push(2);
1710        vec.push(3);
1711
1712        for item in &mut vec {
1713            *item *= 2;
1714        }
1715
1716        assert_eq!(vec.as_slice(), [2, 4, 6]);
1717    }
1718
1719    #[test]
1720    fn test_iterator_size_hint() {
1721        let mut vec = LimitedSizeVec::new();
1722        vec.push(1);
1723        vec.push(2);
1724        vec.push(3);
1725
1726        let iter = vec.into_iter();
1727        assert_eq!(iter.size_hint(), (3, Some(3)));
1728    }
1729
1730    #[test]
1731    fn test_contains_method() {
1732        let mut vec = LimitedSizeVec::new();
1733        vec.push(1);
1734        vec.push(2);
1735        vec.push(3);
1736
1737        assert!(vec.contains(&1));
1738        assert!(vec.contains(&2));
1739        assert!(vec.contains(&3));
1740        assert!(!vec.contains(&4));
1741        assert!(!vec.contains(&0));
1742    }
1743
1744    #[test]
1745    fn test_clear_optimized_for_copy_types() {
1746        // Test with Copy type (no drops needed)
1747        let mut vec: LimitedSizeVec<i32> = LimitedSizeVec::new();
1748        vec.push(1);
1749        vec.push(2);
1750        vec.push(3);
1751
1752        let old_capacity = vec.capacity();
1753        vec.clear();
1754
1755        assert_eq!(vec.len(), 0);
1756        assert_eq!(vec.capacity(), old_capacity);
1757
1758        // Test with non-Copy type (drops needed)
1759        let mut vec = LimitedSizeVec::new();
1760        vec.push(String::from("hello"));
1761        vec.push(String::from("world"));
1762
1763        let old_capacity = vec.capacity();
1764        vec.clear();
1765
1766        assert_eq!(vec.len(), 0);
1767        assert_eq!(vec.capacity(), old_capacity);
1768    }
1769
1770    #[test]
1771    fn test_memory_efficiency_compared_to_std_vec() {
1772        // Test that our struct is smaller than Vec on 64-bit systems
1773        use std::mem::size_of;
1774
1775        // LimitedSizeVec should be smaller due to u32 length/capacity
1776        let limited_size = size_of::<LimitedSizeVec<i32>>();
1777        let std_vec_size = size_of::<Vec<i32>>();
1778
1779        #[cfg(target_pointer_width = "64")]
1780        {
1781            // On 64-bit systems, our vector should be smaller
1782            assert!(limited_size <= std_vec_size);
1783        }
1784
1785        println!("LimitedSizeVec<i32> size: {} bytes", limited_size);
1786        println!("Vec<i32> size: {} bytes", std_vec_size);
1787    }
1788}
qudit_core/utils/limited.rs

qudit_core/utils/
limited.rs
