Struct LimitAccessQueue 

pub struct LimitAccessQueue<T, State> {
    pub val: Vec<T>,
    /* private fields */
}

Fields

val: Vec<T>

Implementations

impl<T, State> LimitAccessQueue<T, State>

where State: Default + Clone,

pub fn new() -> (PrimaryAccessor<T, State>, SecondaryAccessor<T, State>)

pub fn set_state(&mut self, state: State)

pub fn get_state(&mut self) -> State

pub fn pop(&mut self) -> Option<T>

pub fn pop_count(&mut self, count: usize) -> Option<Vec<T>>

pub fn steal(&mut self) -> Option<Vec<T>>

Steals all the un-popped values from the queue. It can then be reused elsewhere.

use parallel_task::{
accessors::limit_queue::LimitAccessQueue,
push_workers::worker_thread::Coordination};
let values = (0..100_000).collect::<Vec<_>>();
let (mut primary, _) = LimitAccessQueue::<i32,Coordination>::new();
_ = primary.write(values);
let vec = primary.steal().unwrap(); //This step should not fail here. But unwrap not advised in production
assert_eq!(vec.len(), 100_000);

pub fn steal_half(&mut self) -> Option<Vec<T>>

Steals half the un-popped values from the queue. It can then be reused elsewhere.

use parallel_task::{
accessors::limit_queue::LimitAccessQueue,
push_workers::worker_thread::Coordination};
let values = (0..100_000).collect::<Vec<_>>();
let (mut primary, _) = LimitAccessQueue::<i32,Coordination>::new();
_ = primary.write(values);
let vec = primary.steal_half().unwrap(); //This step should not fail here. But unwrap not advised in production
assert_eq!(vec.len(), 50_000);

pub fn is_empty(&mut self) -> bool

pub fn len(&mut self) -> usize

pub fn atomic_write_block_to_true(&mut self) -> Result<bool, bool>

pub fn with_write_block<F, Output>(&mut self, f: F) -> Output

where F: FnOnce(&mut Self) -> Output,

pub fn push(&mut self, value: T)

pub fn write(&mut self, values: Vec<T>)

pub fn replace(&mut self, values: Vec<T>)

pub fn is_write_blocked(&self) -> bool