Struct State 

pub struct State<F: Fn(u64) -> Result + Send + Sync> {
    dispatched: u64,
    commit: F,
    pending: VecDeque<u64>,
    release: F,
}

Inner protected state for Two-Phase Counter.

Fields

dispatched: u64

Monotonic counter. The next sequence number is drawn by adding one to this value. That number will be persisted and added to pending.

commit: F

Callback to persist the next sequence number drawn from dispatched. This prevents pending numbers from being reused after server restart.

pending: VecDeque<u64>

List of pending sequence numbers. One less than the minimum value in this list is the “retirement” sequence number where all writes have completed and all reads are globally visible.

release: F

Callback to notify updates of the retirement value. This is likely called from the destructor of a permit/guard; try not to panic.

Implementations

impl<F: Fn(u64) -> Result + Send + Sync> State<F>

fn new(dispatched: u64, commit: F, release: F) -> Self

Create new state, starting from init. The next sequence number dispatched will be one greater than init.

fn dispatch(&mut self) -> Result<(u64, u64)>

Dispatch the next sequence number as pending. The retired value is calculated as a courtesy while the state is under lock.

fn retire(&mut self, id: u64)

Retire the sequence number id.

fn retired(&self) -> u64

Calculate the retired sequence number, one less than the lowest pending sequence number. If nothing is pending the value of dispatched has been previously retired and is returned.

fn pending_index(&self, id: u64) -> Option<usize>

Get the position of id in the pending list.

fn check_pending(&self, id: u64) -> bool

Check for id in the pending list sequentially (for debug and assertion purposes only)