fast_able/
vec2.rs

1use serde::{Deserializer, Serialize, Serializer};
2use spin::{RwLock, RwLockReadGuard, RwLockWriteGuard};
3use std::cell::UnsafeCell;
4use std::fmt::{Debug, Formatter};
5use std::iter::FusedIterator;
6use std::ops::{Index, IndexMut};
7use std::slice::Iter as SliceIter;
8use std::sync::Arc;
9use std::vec::IntoIter;
10
11// Re-export guard types from guard_common
12// 从 guard_common 重新导出守护类型
13pub use crate::guard_common::{MutRefGuard, ReadGuard, RefGuard, WriteGuard};
14
15/// Synchronous vector supporting fine-grained lock control
16/// 同步向量类型，支持细粒度锁控制，更安全地访问数据
17///
18/// Locking strategy:
19/// - Read operations like `get`: Vec read lock + value read lock
20/// - Value modification operations like `get_mut`: Vec read lock + value write lock
21/// - Structure modification operations like `push`/`remove`: Vec write lock
22/// 锁策略:
23/// - get 等读取操作: Vec读锁 + 值的读锁
24/// - get_mut 等修改值操作: Vec读锁 + 值的写锁
25/// - push/remove 等修改结构操作: Vec写锁
26///
27/// This allows:
28/// - Multiple threads can read different values simultaneously
29/// - When one thread modifies a value, other threads can still read other values
30/// - Exclusive access when modifying the Vec structure
31/// 这样可以实现:
32/// - 多个线程可以同时读取不同的值
33/// - 一个线程修改某个值时，其他线程仍可读取其他值
34/// - 修改Vec结构时独占访问
35pub struct SyncVec<V> {
36    dirty: UnsafeCell<Vec<RwLock<V>>>,
37    lock: RwLock<()>,
38}
39
40/// This is safe, dirty mutex ensures safety
41/// 这是安全的，dirty 互斥锁保证了安全性
42unsafe impl<V> Send for SyncVec<V> {}
43
44/// This is safe, dirty mutex ensures safety
45/// 这是安全的，dirty 互斥锁保证了安全性
46unsafe impl<V> Sync for SyncVec<V> {}
47
48impl<V> Default for SyncVec<V> {
49    fn default() -> Self {
50        Self::new()
51    }
52}
53
54impl<V> From<Vec<V>> for SyncVec<V> {
55    fn from(v: Vec<V>) -> Self {
56        Self::with_vec(v)
57    }
58}
59
60impl<V> FromIterator<V> for SyncVec<V> {
61    fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
62        let mut v = Vec::new();
63        for item in iter {
64            v.push(RwLock::new(item));
65        }
66        Self {
67            dirty: UnsafeCell::new(v),
68            lock: RwLock::new(()),
69        }
70    }
71}
72
73impl<V> Extend<V> for SyncVec<V> {
74    fn extend<T: IntoIterator<Item = V>>(&mut self, iter: T) {
75        let v = self.dirty.get_mut();
76        for item in iter {
77            v.push(RwLock::new(item));
78        }
79    }
80}
81
82impl<V> SyncVec<V> {
83    pub fn new_arc() -> Arc<Self> {
84        Arc::new(Self::new())
85    }
86
87    pub const fn new() -> Self {
88        Self {
89            dirty: UnsafeCell::new(Vec::new()),
90            lock: RwLock::new(()),
91        }
92    }
93
94    pub fn with_vec(vec: Vec<V>) -> Self {
95        let mut v = Vec::with_capacity(vec.len());
96        for item in vec {
97            v.push(RwLock::new(item));
98        }
99        Self {
100            dirty: UnsafeCell::new(v),
101            lock: RwLock::new(()),
102        }
103    }
104
105    pub fn with_capacity(capacity: usize) -> Self {
106        Self {
107            dirty: UnsafeCell::new(Vec::with_capacity(capacity)),
108            lock: RwLock::new(()),
109        }
110    }
111
112    #[inline(always)]
113    fn as_arr(&self) -> &Vec<RwLock<V>> {
114        unsafe { &*self.dirty.get() }
115    }
116
117    #[inline(always)]
118    fn as_arr_mut(&self) -> &mut Vec<RwLock<V>> {
119        unsafe { &mut *self.dirty.get() }
120    }
121
122    #[inline(always)]
123    pub fn insert(&self, index: usize, v: V) {
124        let _lock = self.lock.write();
125        self.as_arr_mut().insert(index, RwLock::new(v));
126    }
127
128    #[inline(always)]
129    pub fn push(&self, v: V) {
130        let _lock = self.lock.write();
131        self.as_arr_mut().push(RwLock::new(v));
132    }
133
134    #[inline(always)]
135    pub fn push_return(&self, v: V) -> usize {
136        let _lock = self.lock.write();
137        let u = self.as_arr_mut();
138        let index = u.len();
139        u.push(RwLock::new(v));
140        index
141    }
142
143    #[inline(always)]
144    pub fn push_vec(&self, input_arr: Vec<V>) {
145        let mut _lock = self.lock.write();
146        let u = self.as_arr_mut();
147        for ele in input_arr.into_iter() {
148            u.push(RwLock::new(ele));
149        }
150    }
151
152    pub fn pop(&self) -> Option<V> {
153        let _lock = self.lock.write();
154        let u = self.as_arr_mut();
155        u.pop().map(|v| v.into_inner())
156    }
157
158    pub fn remove(&self, index: usize) -> Option<V> {
159        let _lock = self.lock.write();
160        let u = self.as_arr_mut();
161        if u.len() > index {
162            let v = u.remove(index);
163            Some(v.into_inner())
164        } else {
165            None
166        }
167    }
168
169    pub fn len(&self) -> usize {
170        let _lock = self.lock.read();
171        let u = self.as_arr();
172        u.len()
173    }
174
175    pub fn is_empty(&self) -> bool {
176        let _lock = self.lock.read();
177        let u = self.as_arr();
178        u.is_empty()
179    }
180
181    pub fn clear(&self) {
182        let _lock = self.lock.write();
183        let u = self.as_arr_mut();
184        u.clear();
185    }
186
187    pub fn shrink_to_fit(&self) {
188        let _lock = self.lock.write();
189        let u = self.as_arr_mut();
190        u.shrink_to_fit();
191    }
192
193    /// Get a reference to the value at index, protected by Vec read lock (value no lock)
194    /// 获取索引处的值引用，使用Vec读锁 (值无锁)
195    ///
196    /// # Safety
197    /// 此方法绕过了保护值的 `RwLock`，仅当您确定没有其他线程正在修改该值时才应使用它。
198    /// This method bypasses the `RwLock` protecting the value.
199    /// It should only be used when you are sure that no other thread is modifying the value.
200    #[inline]
201    pub fn get(&self, index: usize) -> Option<RefGuard<'_, V>> {
202        let _lock = self.lock.read();
203        let u = self.as_arr();
204        if let Some(v_lock) = u.get(index) {
205            // SAFETY: 只有Vec结构锁保护，值无锁
206            let value_ptr = unsafe {
207                let lock_ptr = v_lock as *const RwLock<V> as *mut RwLock<V>;
208                &*(*lock_ptr).get_mut()
209            };
210            Some(RefGuard {
211                _lock,
212                _value: value_ptr,
213            })
214        } else {
215            None
216        }
217    }
218
219    /// Get a reference to the value at index (unchecked), protected by Vec read lock (value no lock)
220    /// 获取索引处的值引用（无检查），使用Vec读锁 (值无锁)
221    ///
222    /// # Safety
223    /// 此方法绕过了保护值的 `RwLock`，仅当您确定没有其他线程正在修改该值时才应使用它。
224    /// This method bypasses the `RwLock` protecting the value.
225    /// It should only be used when you are sure that no other thread is modifying the value.
226    #[inline]
227    pub fn get_uncheck(&self, index: usize) -> RefGuard<'_, V> {
228        let _lock = self.lock.read();
229        let u = self.as_arr();
230        let v_lock = &u[index];
231        // SAFETY: 只有Vec结构锁保护，值无锁
232        let value_ptr = unsafe {
233            let lock_ptr = v_lock as *const RwLock<V> as *mut RwLock<V>;
234            &*(*lock_ptr).get_mut()
235        };
236        RefGuard {
237            _lock,
238            _value: value_ptr,
239        }
240    }
241
242    /// Get a reference to the value at index, protected by Vec read lock + value read lock
243    /// 获取索引处的值引用，使用Vec读锁 + 值的读锁保护
244    #[inline]
245    pub fn get_rlock(&self, index: usize) -> Option<ReadGuard<'_, V>> {
246        let _lock = self.lock.read();
247        let u = self.as_arr();
248        if let Some(v_lock) = u.get(index) {
249            let _value_lock = v_lock.read();
250            Some(ReadGuard { _lock, _value_lock })
251        } else {
252            None
253        }
254    }
255
256    /// Get a mutable reference to the value at index, protected by Vec read lock + value write lock
257    /// 获取索引处的可变值引用，使用Vec读锁 + 值的写锁保护
258    #[inline]
259    pub fn get_mut_lock(&self, index: usize) -> Option<WriteGuard<'_, V>> {
260        let _lock = self.lock.read();
261        let u = self.as_arr();
262        if let Some(v_lock) = u.get(index) {
263            let _value_lock = v_lock.write();
264            Some(WriteGuard { _lock, _value_lock })
265        } else {
266            None
267        }
268    }
269
270    /// Get a mutable reference to the value at index, protected by Vec read lock (value no lock)
271    /// 获取索引处的可变值引用，使用Vec读锁 (值无锁)
272    #[inline]
273    pub fn get_mut(&self, index: usize) -> Option<MutRefGuard<'_, V>> {
274        let _lock = self.lock.read();
275        let u = self.as_arr();
276        if let Some(v_lock) = u.get(index) {
277            let value_ptr = unsafe {
278                let lock_ptr = v_lock as *const RwLock<V> as *mut RwLock<V>;
279                &mut *(*lock_ptr).get_mut()
280            };
281            Some(MutRefGuard {
282                _lock,
283                _value: value_ptr,
284            })
285        } else {
286            None
287        }
288    }
289
290    #[inline]
291    pub fn contains(&self, x: &V) -> bool
292    where
293        V: PartialEq,
294    {
295        let _lock = self.lock.read();
296        let u = self.as_arr();
297        for item in u {
298            let value_ptr = unsafe {
299                let lock_ptr = item as *const RwLock<V> as *mut RwLock<V>;
300                &*(*lock_ptr).get_mut()
301            };
302            if value_ptr == x {
303                return true;
304            }
305        }
306        false
307    }
308
309    #[inline]
310    pub fn contains_lock(&self, x: &V) -> bool
311    where
312        V: PartialEq,
313    {
314        let _lock = self.lock.read();
315        let u = self.as_arr();
316        for item in u {
317            if *item.read() == *x {
318                return true;
319            }
320        }
321        false
322    }
323
324    /// Safety; Get an iterator over the values, protected by Vec read lock + individual value read locks
325    /// 安全地访问每个数据，获取迭代器，使用Vec读锁 + 各个值的读锁保护
326    pub fn iter_rlock(&self) -> IterRLock<'_, V> {
327        let _lock = self.lock.read();
328        let u = self.as_arr();
329        IterRLock {
330            _lock,
331            inner: u.iter(),
332        }
333    }
334
335    /// 不锁值，只锁Vec结构，适用于只读但不修改值的场景
336    ///
337    /// # Safety
338    /// 此方法是不安全的，因为它绕过了保护每个值的 `RwLock`。
339    /// 仅当您确定没有其他线程正在修改这些值时才应使用它。
340    ///
341    /// This method is unsafe because it bypasses the `RwLock` protecting each value.
342    /// It should only be used when you are sure that no other thread is modifying the values.
343    pub fn iter(&self) -> Iter<'_, V> {
344        let _lock = self.lock.read();
345        let u = self.as_arr();
346        Iter {
347            _lock,
348            inner: u.iter(),
349        }
350    }
351
352    /// Get a mutable iterator over the values, protected by Vec read lock + individual value write locks
353    /// 获取可变迭代器，使用Vec读锁 + 各个值的写锁保护
354    pub fn iter_mut_lock(&self) -> IterLock<'_, V> {
355        let _lock = self.lock.read();
356        let u = self.as_arr();
357        IterLock {
358            _lock,
359            inner: u.iter(),
360        }
361    }
362
363    /// Get a mutable iterator over the values, protected by Vec read lock (value no lock)
364    /// 获取可变迭代器，使用Vec读锁 (值无锁)
365    ///
366    /// # Safety
367    /// 此方法绕过了保护每个值的 `RwLock`。
368    /// 仅当您确定没有其他线程正在修改这些值时才应使用它。
369    ///
370    /// This method bypasses the `RwLock` protecting each value.
371    /// It should only be used when you are sure that no other thread is modifying the values.
372    pub fn iter_mut(&self) -> IterMut<'_, V> {
373        let _lock = self.lock.read();
374        let u = self.as_arr();
375        IterMut {
376            _lock,
377            inner: u.iter(),
378        }
379    }
380
381    pub fn into_iter(self) -> IntoIter<V> {
382        let _lock = self.lock.write();
383        let m = self.dirty.into_inner();
384        let mut v = Vec::with_capacity(m.len());
385        for item in m {
386            v.push(item.into_inner());
387        }
388        v.into_iter()
389    }
390
391    pub fn dirty_ref(&self) -> RefGuard<'_, Vec<RwLock<V>>> {
392        RefGuard {
393            _lock: self.lock.read(),
394            _value: self.as_arr(),
395        }
396    }
397
398    pub fn into_inner(self) -> Vec<V> {
399        let m = self.dirty.into_inner();
400        let mut v = Vec::with_capacity(m.len());
401        for item in m {
402            v.push(item.into_inner());
403        }
404        v
405    }
406
407    pub fn to_vec(&self) -> Vec<V>
408    where
409        V: Clone,
410    {
411        let _lock = self.lock.read();
412        let u = self.as_arr();
413        let mut v = Vec::with_capacity(u.len());
414        for item in u {
415            v.push(item.read().clone());
416        }
417        v
418    }
419}
420
421pub struct IterRLock<'a, V> {
422    pub(crate) _lock: RwLockReadGuard<'a, ()>,
423    pub(crate) inner: SliceIter<'a, RwLock<V>>,
424}
425
426impl<'a, V> Iterator for IterRLock<'a, V> {
427    type Item = RwLockReadGuard<'a, V>;
428    fn next(&mut self) -> Option<Self::Item> {
429        self.inner.next().map(|v| v.read())
430    }
431}
432
433impl<'a, V> ExactSizeIterator for IterRLock<'a, V> {
434    fn len(&self) -> usize {
435        self.inner.len()
436    }
437}
438
439impl<'a, V> DoubleEndedIterator for IterRLock<'a, V> {
440    fn next_back(&mut self) -> Option<Self::Item> {
441        self.inner.next_back().map(|v| v.read())
442    }
443}
444
445impl<'a, V> FusedIterator for IterRLock<'a, V> {}
446
447pub struct IterLock<'a, V> {
448    pub(crate) _lock: RwLockReadGuard<'a, ()>,
449    pub(crate) inner: SliceIter<'a, RwLock<V>>,
450}
451
452impl<'a, V> Iterator for IterLock<'a, V> {
453    type Item = RwLockWriteGuard<'a, V>;
454
455    fn next(&mut self) -> Option<Self::Item> {
456        self.inner.next().map(|v| v.write())
457    }
458}
459
460impl<'a, V> ExactSizeIterator for IterLock<'a, V> {
461    fn len(&self) -> usize {
462        self.inner.len()
463    }
464}
465
466impl<'a, V> DoubleEndedIterator for IterLock<'a, V> {
467    fn next_back(&mut self) -> Option<Self::Item> {
468        self.inner.next_back().map(|v| v.write())
469    }
470}
471
472impl<'a, V> FusedIterator for IterLock<'a, V> {}
473
474/// 不锁值的迭代器，只锁Vec结构
475/// Iterator that only locks Vec structure, not individual values
476pub struct Iter<'a, V> {
477    pub(crate) _lock: RwLockReadGuard<'a, ()>,
478    pub(crate) inner: SliceIter<'a, RwLock<V>>,
479}
480
481impl<'a, V> Iterator for Iter<'a, V> {
482    type Item = &'a V;
483
484    fn next(&mut self) -> Option<Self::Item> {
485        self.inner.next().map(|v| {
486            // SAFETY: 调用者通过使用 unsafe fn iter 保证没有并发写入
487            unsafe {
488                let lock_ptr = v as *const RwLock<V> as *mut RwLock<V>;
489                &*(*lock_ptr).get_mut()
490            }
491        })
492    }
493}
494
495impl<'a, V> ExactSizeIterator for Iter<'a, V> {
496    fn len(&self) -> usize {
497        self.inner.len()
498    }
499}
500
501impl<'a, V> DoubleEndedIterator for Iter<'a, V> {
502    fn next_back(&mut self) -> Option<Self::Item> {
503        self.inner.next_back().map(|v| {
504            // SAFETY: 调用者通过使用 unsafe fn iter 保证没有并发写入
505            unsafe {
506                let lock_ptr = v as *const RwLock<V> as *mut RwLock<V>;
507                &*(*lock_ptr).get_mut()
508            }
509        })
510    }
511}
512
513impl<'a, V> FusedIterator for Iter<'a, V> {}
514
515/// 不锁值的可变迭代器，只锁Vec结构
516/// Mutable iterator that only locks Vec structure, not individual values
517pub struct IterMut<'a, V> {
518    pub(crate) _lock: RwLockReadGuard<'a, ()>,
519    pub(crate) inner: SliceIter<'a, RwLock<V>>,
520}
521
522impl<'a, V> Iterator for IterMut<'a, V> {
523    type Item = &'a mut V;
524
525    fn next(&mut self) -> Option<Self::Item> {
526        self.inner.next().map(|v| {
527            // SAFETY: 调用者通过使用此方法保证没有并发写入
528            unsafe {
529                let lock_ptr = v as *const RwLock<V> as *mut RwLock<V>;
530                &mut *(*lock_ptr).get_mut()
531            }
532        })
533    }
534}
535
536impl<'a, V> ExactSizeIterator for IterMut<'a, V> {
537    fn len(&self) -> usize {
538        self.inner.len()
539    }
540}
541
542impl<'a, V> DoubleEndedIterator for IterMut<'a, V> {
543    fn next_back(&mut self) -> Option<Self::Item> {
544        self.inner.next_back().map(|v| {
545            // SAFETY: 调用者通过使用此方法保证没有并发写入
546            unsafe {
547                let lock_ptr = v as *const RwLock<V> as *mut RwLock<V>;
548                &mut *(*lock_ptr).get_mut()
549            }
550        })
551    }
552}
553
554impl<'a, V> FusedIterator for IterMut<'a, V> {}
555
556impl<'a, V> IntoIterator for &'a SyncVec<V> {
557    type Item = &'a V;
558    type IntoIter = Iter<'a, V>;
559
560    fn into_iter(self) -> Self::IntoIter {
561        self.iter()
562    }
563}
564
565impl<'a, V> IntoIterator for &'a mut SyncVec<V> {
566    type Item = &'a mut V;
567    type IntoIter = IterMut<'a, V>;
568
569    fn into_iter(self) -> Self::IntoIter {
570        self.iter_mut()
571    }
572}
573
574impl<V> IntoIterator for SyncVec<V> {
575    type Item = V;
576    type IntoIter = IntoIter<V>;
577
578    fn into_iter(self) -> Self::IntoIter {
579        self.into_iter()
580    }
581}
582
583impl<V> Serialize for SyncVec<V>
584where
585    V: Serialize,
586{
587    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
588    where
589        S: Serializer,
590    {
591        use serde::ser::SerializeSeq;
592        let _lock = self.lock.read();
593        let v = unsafe { &*self.dirty.get() };
594        let mut seq = serializer.serialize_seq(Some(v.len()))?;
595        for element in v {
596            seq.serialize_element(&*element.read())?;
597        }
598        seq.end()
599    }
600}
601
602impl<'de, V> serde::Deserialize<'de> for SyncVec<V>
603where
604    V: serde::Deserialize<'de>,
605{
606    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
607    where
608        D: Deserializer<'de>,
609    {
610        let m = Vec::deserialize(deserializer)?;
611        Ok(Self::from(m))
612    }
613}
614
615impl<V> Debug for SyncVec<V>
616where
617    V: Debug,
618{
619    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
620        write!(f, "{:?}", self.dirty_ref())
621    }
622}
623
624impl<V: std::fmt::Display> std::fmt::Display for SyncVec<V> {
625    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
626        let _lock = self.lock.read();
627        let v = unsafe { &*self.dirty.get() };
628        write!(f, "[")?;
629        for (i, item) in v.iter().enumerate() {
630            if i > 0 {
631                write!(f, ", ")?;
632            }
633            write!(f, "{}", item.read())?;
634        }
635        write!(f, "]")
636    }
637}
638
639impl<V: PartialEq> PartialEq for SyncVec<V> {
640    fn eq(&self, other: &Self) -> bool {
641        let _lock1 = self.lock.read();
642        let _lock2 = other.lock.read();
643        let v1 = unsafe { &*self.dirty.get() };
644        let v2 = unsafe { &*other.dirty.get() };
645        if v1.len() != v2.len() {
646            return false;
647        }
648        for (i1, i2) in v1.iter().zip(v2.iter()) {
649            if *i1.read() != *i2.read() {
650                return false;
651            }
652        }
653        true
654    }
655}
656
657impl<V: Clone> Clone for SyncVec<V> {
658    fn clone(&self) -> Self {
659        let _lock = self.lock.read();
660        let v = unsafe { &*self.dirty.get() };
661        let mut new_vec = Vec::with_capacity(v.len());
662        for item in v {
663            new_vec.push(RwLock::new(item.read().clone()));
664        }
665        Self {
666            dirty: UnsafeCell::new(new_vec),
667            lock: RwLock::new(()),
668        }
669    }
670}
671
672impl<V> Index<usize> for SyncVec<V> {
673    type Output = V;
674
675    /// Get a reference to the value at index, bypassing the lock.
676    /// 获取索引处的值引用，绕过锁。
677    ///
678    /// # Safety
679    /// This method is unsafe because it bypasses the `RwLock` protecting the value.
680    /// It should only be used when you are sure that no other thread is modifying the value.
681    /// Concurrent access using this method is undefined behavior.
682    ///
683    /// # 安全性
684    /// 此方法是不安全的，因为它绕过了保护值的 `RwLock`。
685    /// 仅当您确定没有其他线程正在修改该值时才应使用它。
686    /// 使用此方法进行并发访问是未定义行为。
687    fn index(&self, index: usize) -> &Self::Output {
688        unsafe {
689            let v = &*self.dirty.get();
690            // We need to get &V from &RwLock<V> without locking.
691            // Since we are in an unsafe block and claiming it's unsafe/no concurrent access,
692            // we can cast the &RwLock<V> to &mut RwLock<V> (conceptually) to use get_mut(),
693            // or rely on the fact that we are bypassing the lock.
694            // However, RwLock::get_mut requires &mut RwLock.
695            // We only have &RwLock.
696            // We can cast &RwLock to &mut RwLock because we are asserting exclusive access (via the safety contract).
697            let lock_ptr = &v[index] as *const RwLock<V> as *mut RwLock<V>;
698            (*lock_ptr).get_mut()
699        }
700    }
701}
702
703impl<V> IndexMut<usize> for SyncVec<V> {
704    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
705        // This is unsafe because we are bypassing the `RwLock` protecting the value.
706        // 这是不安全的，因为我们绕过了保护值的 `RwLock`。
707        let v = self.dirty.get_mut();
708        v[index].get_mut()
709    }
710}
711
712#[macro_export]
713macro_rules! sync_vec {
714    () => (
715        $crate::SyncVec::new()
716    );
717    ($elem:expr; $n:expr) => (
718        $crate::SyncVec::with_vec(vec![$elem;$n])
719    );
720    ($($x:expr),+ $(,)?) => (
721        $crate::SyncVec::with_vec(vec![$($x),+,])
722    );
723}
724
725#[test]
726fn test_case() {
727    struct D {}
728    impl D {
729        fn is_some(&self) -> bool {
730            println!("is_some");
731            true
732        }
733        fn take(&mut self) -> Option<bool> {
734            println!("take");
735            Some(true)
736        }
737    }
738
739    let mut d = D {};
740    if let (true, Some(d)) = (d.is_some(), d.take()) {
741        println!("d is {d}");
742    }
743}
744
745#[cfg(test)]
746mod tests {
747    use super::*;
748    use std::sync::Arc;
749    use std::thread;
750
751    #[test]
752    fn test_new_and_capacity() {
753        let vec: SyncVec<i32> = SyncVec::new();
754        assert!(vec.is_empty());
755        assert_eq!(vec.len(), 0);
756
757        let vec: SyncVec<i32> = SyncVec::with_capacity(10);
758        assert!(vec.is_empty());
759        assert_eq!(vec.len(), 0);
760    }
761
762    #[test]
763    fn test_push_and_get() {
764        let vec = SyncVec::new();
765        vec.push(1);
766        vec.push(2);
767        vec.push(3);
768
769        assert_eq!(vec.len(), 3);
770        assert_eq!(*vec.get(0).unwrap(), 1);
771        assert_eq!(*vec.get(1).unwrap(), 2);
772        assert_eq!(*vec.get(2).unwrap(), 3);
773        assert!(vec.get(3).is_none());
774    }
775
776    #[test]
777    fn test_index_methods() {
778        let mut vec = SyncVec::new();
779        vec.push(10);
780        vec.push(20);
781
782        assert_eq!(vec[0], 10);
783        assert_eq!(vec[1], 20);
784
785        {
786            let val = &mut vec[0];
787            *val = 100;
788        }
789        assert_eq!(vec[0], 100);
790    }
791
792    #[test]
793    #[should_panic(expected = "index out of bounds")]
794    fn test_index_panic() {
795        let vec = SyncVec::new();
796        vec.push(1);
797        let _ = vec[1];
798    }
799
800    #[test]
801    #[should_panic(expected = "index out of bounds")]
802    fn test_index_mut_panic() {
803        let mut vec = SyncVec::new();
804        vec.push(1);
805        let _ = &mut vec[1];
806    }
807
808    #[test]
809    fn test_remove_and_pop() {
810        let vec = SyncVec::new();
811        vec.push(1);
812        vec.push(2);
813        vec.push(3);
814
815        assert_eq!(vec.pop(), Some(3));
816        assert_eq!(vec.len(), 2);
817
818        assert_eq!(vec.remove(0), Some(1));
819        assert_eq!(vec.len(), 1);
820        assert_eq!(*vec.get(0).unwrap(), 2);
821    }
822
823    #[test]
824    fn test_concurrency() {
825        let vec = Arc::new(SyncVec::new());
826        let mut handles = vec![];
827
828        // Multiple writers
829        for i in 0..10 {
830            let vec = vec.clone();
831            handles.push(thread::spawn(move || {
832                for j in 0..100 {
833                    vec.push(i * 100 + j);
834                }
835            }));
836        }
837
838        for handle in handles {
839            handle.join().unwrap();
840        }
841
842        assert_eq!(vec.len(), 1000);
843    }
844
845    #[test]
846    fn test_concurrent_modify() {
847        let vec = Arc::new(SyncVec::new());
848        for i in 0..100 {
849            vec.push(i);
850        }
851
852        let vec_clone = vec.clone();
853        let handle = thread::spawn(move || {
854            for i in 0..100 {
855                if let Some(mut guard) = vec_clone.get_mut(i) {
856                    *guard += 1;
857                }
858            }
859        });
860
861        // Concurrent read
862        for i in 0..100 {
863            if let Some(val) = vec.get(i) {
864                let _ = *val; // Just read
865            }
866        }
867
868        handle.join().unwrap();
869
870        // Verify modifications
871        for i in 0..100 {
872            assert_eq!(*vec.get(i).unwrap(), i + 1);
873        }
874    }
875
876    #[test]
877    fn test_iter() {
878        let vec = SyncVec::new();
879        vec.push(1);
880        vec.push(2);
881        vec.push(3);
882
883        let mut sum = 0;
884        for item in vec.iter() {
885            sum += *item;
886        }
887        assert_eq!(sum, 6);
888    }
889
890    #[test]
891    fn test_iter_mut() {
892        let vec = SyncVec::new();
893        vec.push(1);
894        vec.push(2);
895        vec.push(3);
896
897        for mut item in vec.iter_mut() {
898            *item *= 2;
899        }
900
901        assert_eq!(*vec.get(0).unwrap(), 2);
902        assert_eq!(*vec.get(1).unwrap(), 4);
903        assert_eq!(*vec.get(2).unwrap(), 6);
904    }
905
906    #[test]
907    fn test_clear() {
908        let vec = SyncVec::new();
909        vec.push(1);
910        vec.clear();
911        assert!(vec.is_empty());
912    }
913
914    #[test]
915    fn test_contains() {
916        let vec = SyncVec::new();
917        vec.push(1);
918        vec.push(2);
919        assert!(vec.contains(&1));
920        assert!(!vec.contains(&3));
921    }
922
923    #[test]
924    fn test_iterator_traits() {
925        let vec = SyncVec::new();
926        vec.push(1);
927        vec.push(2);
928        vec.push(3);
929
930        let mut iter = vec.iter();
931        assert_eq!(iter.len(), 3);
932        assert_eq!(*iter.next().unwrap(), 1);
933        assert_eq!(iter.len(), 2);
934        assert_eq!(*iter.next_back().unwrap(), 3);
935        assert_eq!(iter.len(), 1);
936        assert_eq!(*iter.next().unwrap(), 2);
937        assert_eq!(iter.len(), 0);
938        assert!(iter.next().is_none());
939        assert!(iter.next_back().is_none());
940
941        let mut vec = SyncVec::new();
942        vec.push(1);
943        vec.push(2);
944        vec.push(3);
945        let mut iter_mut = vec.iter_mut();
946        assert_eq!(iter_mut.len(), 3);
947        assert_eq!(*iter_mut.next().unwrap(), 1);
948        assert_eq!(iter_mut.len(), 2);
949        assert_eq!(*iter_mut.next_back().unwrap(), 3);
950        assert_eq!(iter_mut.len(), 1);
951        assert_eq!(*iter_mut.next().unwrap(), 2);
952        assert_eq!(iter_mut.len(), 0);
953        assert!(iter_mut.next().is_none());
954        assert!(iter_mut.next_back().is_none());
955    }
956
957    #[test]
958    fn test_from_iter_and_extend() {
959        let vec: SyncVec<i32> = SyncVec::from_iter(vec![1, 2, 3]);
960        assert_eq!(vec.len(), 3);
961        assert_eq!(*vec.get(0).unwrap(), 1);
962
963        let mut vec = SyncVec::new();
964        vec.extend(vec![1, 2, 3]);
965        assert_eq!(vec.len(), 3);
966        assert_eq!(*vec.get(0).unwrap(), 1);
967    }
968
969    #[test]
970    fn test_iter_notlock() {
971        let vec = SyncVec::new();
972        vec.push(1);
973        vec.push(2);
974        vec.push(3);
975
976        // 测试 iter 基本功能
977        let mut sum = 0;
978        for item in vec.iter() {
979            sum += *item;
980        }
981        assert_eq!(sum, 6);
982
983        // 测试 ExactSizeIterator
984        let iter = vec.iter();
985        assert_eq!(iter.len(), 3);
986    }
987
988    #[test]
989    fn test_iter_double_ended() {
990        let vec = SyncVec::new();
991        vec.push(1);
992        vec.push(2);
993        vec.push(3);
994
995        let mut iter = vec.iter();
996        assert_eq!(*iter.next().unwrap(), 1);
997        assert_eq!(*iter.next_back().unwrap(), 3);
998        assert_eq!(*iter.next().unwrap(), 2);
999        assert!(iter.next().is_none());
1000    }
1001
1002    #[test]
1003    fn test_iter_empty() {
1004        let vec: SyncVec<i32> = SyncVec::new();
1005
1006        let mut count = 0;
1007        for _ in vec.iter() {
1008            count += 1;
1009        }
1010        assert_eq!(count, 0);
1011
1012        let iter = vec.iter();
1013        assert_eq!(iter.len(), 0);
1014    }
1015
1016    #[test]
1017    fn test_into_iter_ref() {
1018        let vec = SyncVec::new();
1019        vec.push(10);
1020        vec.push(20);
1021        vec.push(30);
1022
1023        // 测试 IntoIterator for &SyncVec
1024        let mut sum = 0;
1025        for item in &vec {
1026            sum += *item;
1027        }
1028        assert_eq!(sum, 60);
1029
1030        // 确保 vec 仍然可用
1031        assert_eq!(vec.len(), 3);
1032    }
1033
1034    #[test]
1035    fn test_into_iter_mut() {
1036        let mut vec = SyncVec::new();
1037        vec.push(1);
1038        vec.push(2);
1039        vec.push(3);
1040
1041        // 测试 IntoIterator for &mut SyncVec
1042        for mut item in &mut vec {
1043            *item *= 2;
1044        }
1045
1046        assert_eq!(*vec.get(0).unwrap(), 2);
1047        assert_eq!(*vec.get(1).unwrap(), 4);
1048        assert_eq!(*vec.get(2).unwrap(), 6);
1049    }
1050
1051    #[test]
1052    fn test_into_iter_owned() {
1053        let vec = SyncVec::new();
1054        vec.push(1);
1055        vec.push(2);
1056        vec.push(3);
1057
1058        // 测试 IntoIterator for SyncVec (消耗所有权)
1059        let collected: Vec<_> = vec.into_iter().collect();
1060        assert_eq!(collected, vec![1, 2, 3]);
1061    }
1062}
fast_able/vec2.rs

fast_able/
vec2.rs
