Struct voluntary_servitude::VoluntaryServitude

pub struct VoluntaryServitude<T> { /* private fields */ }

Lock-free appendable list (also called VS)

Parallel examples in main lib docs

let list = vs![3, 2];
assert_eq!(list.len(), 2);
assert_eq!(list.iter().collect::<Vec<_>>(), vec![&3, &2]);

list.clear();
assert!(list.is_empty());

// You can deep copy a `VS` if T is Copy
use std::iter::FromIterator;
let list2 = VS::from_iter(list.iter());
list2.append(3);
assert_eq!(list.len() + 1, list2.len());

for el in list.iter() {
    assert_eq!(el, &3);
}

Implementations

impl<T> VoluntaryServitude<T>

pub fn len(&self) -> usize

Atomically extracts current size, be careful with data-races when using it

May grow or be set to 0

let list = vs![3, 2];
assert_eq!(list.len(), 2);
list.append(5);
assert_eq!(list.len(), 3);
list.clear();
assert_eq!(list.len(), 0);

pub fn is_empty(&self) -> bool

Atomically checks if VS is empty, be careful with data-races when using it

let list = vs![];
assert!(list.is_empty());
list.append(());
assert!(!list.is_empty());

pub fn iter<'a>(&self) -> VSIter<'a, T>

Makes lock-free iterator based on VoluntaryServitude

let list = vs![3, 2];
assert_eq!(list.iter().collect::<Vec<_>>(), vec![&3, &2]);

pub fn clear(&self)

Clears list (iterators referencing old chain will still work)

let list = vs![3, 2];
let iter = list.iter();
list.clear();
assert_eq!(iter.len(), 2);
assert_eq!(list.len(), 0);

pub fn append(&self, value: T)

Insert element after last node

let list = vs![];
let mut iter = list.iter();
list.append(3);
assert!(iter.is_empty());
iter = list.iter();
list.append(8);
assert_eq!(iter.collect::<Vec<_>>(), vec![&3, &8]);

Trait Implementations

impl<T: Debug> Debug for VoluntaryServitude<T>

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

Formats the value using the given formatter.

impl<T> Default for VoluntaryServitude<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: 'a + Deserialize<'a>> Deserialize<'a> for VoluntaryServitude<T>

fn deserialize<D: Deserializer<'a>>(des: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T> Drop for VoluntaryServitude<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: 'a + Copy> FromIterator<&'a T> for VoluntaryServitude<T>

fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> FromIterator<T> for VoluntaryServitude<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for VoluntaryServitude<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq<VoluntaryServitude<T>> for VoluntaryServitude<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize> Serialize for VoluntaryServitude<T>

Available on crate feature serde-traits only.

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

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for VoluntaryServitude<T>