Struct OnceList

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

use std::sync::{atomic::{AtomicU32, Ordering}};
use std::thread;
use once_list::OnceList;

// Let's exercise this new Sync append-only list by doing a little counting
static LIST: OnceList<u32> = OnceList::new();
static COUNTER: AtomicU32 = AtomicU32::new(0);

let vec = (0..thread::available_parallelism().unwrap().get()).map(|_| thread::spawn(|| {
    while let i @ 0..1000 = COUNTER.fetch_add(1, Ordering::Relaxed) {
        LIST.push(i);
    }
})).collect::<Vec<thread::JoinHandle<_>>>();
vec.into_iter().for_each(|handle| handle.join().unwrap());

for i in 0..1000 {
    assert!(LIST.contains(&i));
}

Implementations

impl<T> OnceList<T>

pub const fn new() -> OnceList<T>

pub fn push(&self, value: T)

pub fn contains(&self, example: &T) -> bool

where T: PartialEq,

Trait Implementations

impl<T: Clone> Clone for OnceList<T>

fn clone(&self) -> OnceList<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for OnceList<T>

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

Formats the value using the given formatter.

impl<T> Default for OnceList<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PartialEq> PartialEq for OnceList<T>

fn eq(&self, other: &OnceList<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq> Eq for OnceList<T>

impl<T> StructuralPartialEq for OnceList<T>