Struct SyncVec 

pub struct SyncVec<V> { /* private fields */ }

A concurrent Vec with a Go sync.Map-style read/dirty architecture:

• read: an immutable snapshot, atomically published. get / iter read it lock-free.
• dirty: the canonical, mutable vec, guarded by lock.

Every slot is an Arc<Entry<V>> shared between the snapshot and dirty. The entry holds an atomic pointer to the value, so set swaps the pointer in place (O(1)) — no snapshot rebuild — and readers always see the latest value. Appends are published lazily (tracked by the amended flag), while index-shifting operations (insert/remove/pop) rebuild the snapshot. Snapshots and retired values are kept alive until the vec is dropped, so references returned by get stay valid.

Implementations

impl<V> SyncVec<V>

pub fn new_arc() -> Arc<Self>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn with_vec(vec: Vec<V>) -> Self

pub fn insert(&self, index: usize, v: V) -> Option<V>

pub fn set(&self, index: usize, v: V) -> Option<V>

pub fn push(&self, v: V) -> Option<V>

pub fn pushes(&self, arr: Vec<V>) -> Option<V>

pub fn push_mut(&mut self, v: V) -> Option<V>

pub fn pop(&self) -> Option<V>

where V: Clone,

Remove and return the last element.

This requires V: Clone because the removed value must stay alive for concurrent readers. Use pop_discard when the value is not Clone and the removed value is not needed.

pub fn pop_mut(&mut self) -> Option<V>

where V: Clone,

pub fn pop_discard(&self)

Remove and discard the last element without returning it. Unlike pop this does not require V: Clone, so it works with non-Clone values.

pub fn pop_discard_mut(&mut self)

pub fn remove(&self, index: usize) -> Option<V>

where V: Clone,

Remove and return the element at index.

This requires V: Clone because the removed value must stay alive for concurrent readers. Use remove_discard when the value is not Clone and the removed value is not needed.

pub fn remove_mut(&mut self, index: usize) -> Option<V>

where V: Clone,

pub fn remove_discard(&self, index: usize)

Remove and discard the element at index without returning it. Unlike remove this does not require V: Clone, so it works with non-Clone values.

pub fn remove_discard_mut(&mut self, index: usize)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&self)

pub fn shrink_to_fit(&self)

pub fn from(vec: Vec<V>) -> Self

pub fn get(&self, index: usize) -> Option<&V>

Returns a reference to the element at index.

Reads are lock-free: the value is served from the immutable read snapshot through a shared entry, so set is visible immediately. If the index was appended to dirty since the last snapshot was published, a fresh snapshot is published first.

pub unsafe fn get_uncheck(&self, index: usize) -> &V

pub fn get_mut(&self, index: usize) -> Option<VecRefMut<'_, V>>

where V: Clone,

Returns a mutable handle to the element at index, implemented with copy-on-write: the value is cloned, the handle mutates the clone, and the result is swapped back into the shared entry (O(1)) when the handle is dropped. Concurrent readers may observe the pre-mutation value until the handle is dropped.

pub fn contains(&self, x: &V) -> bool

where V: PartialEq,

pub fn iter(&self) -> Iter<'_, V>

Iterate over the current contents. A fresh snapshot is published first, so all elements written so far are visible.

pub fn iter_mut(&self) -> IterMut<'_, V>

where V: Clone,

pub fn into_iter(self) -> IntoIter<V>

pub fn into_inner(self) -> Vec<V>

Trait Implementations

impl<V: Clone> Clone for SyncVec<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V> Debug for SyncVec<V>

where V: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V> Default for SyncVec<V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V> Deserialize<'de> for SyncVec<V>

where V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V> Display for SyncVec<V>

where V: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V> Index<usize> for SyncVec<V>

type Output = V

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, V> IntoIterator for &'a SyncVec<V>

type Item = &'a V

The type of the elements being iterated over.

type IntoIter = Iter<'a, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V> IntoIterator for SyncVec<V>

type Item = V

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V: PartialEq> PartialEq for SyncVec<V>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<V> Send for SyncVec<V>

Safety: dirty is only ever accessed under lock; the read snapshot is immutable once published; values behind entries are immutable once published and swapped out atomically; retired values and retired snapshots are kept alive until the vec is dropped, so references derived from get remain valid for the lifetime of &self.

impl<V> Serialize for SyncVec<V>

where V: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<V> Sync for SyncVec<V>