Struct Queue

pub struct Queue<V: DeserializeOwned + Serialize>(/* private fields */);

Implementations

impl<V: DeserializeOwned + Serialize + 'static> Queue<V>

pub fn open( base_dir: impl AsRef<Path>, config: KeyValConfig, signal_change: Option<PollingSignalsSender>, ) -> Result<Self, KeyValError>

pub fn key_val(&self) -> &KeyVal<TimeKey, V>

Give access to the underlying key-value database. WARNING: it will be possible to mess up the queue this way.

pub fn key_val_mut(&mut self) -> &mut KeyVal<TimeKey, V>

Give access to the underlying key-value database. WARNING: it will be possible to mess up the queue this way.

pub fn base_dir(&self) -> &PathBuf

pub fn get_entry<'s>( &'s self, key: &TimeKey, ) -> Result<Option<Entry<'s, TimeKey, V>>, KeyValError>

pub fn get_item<'s>( &'s self, key: &TimeKey, opts: QueueGetItemOptions, ) -> Result<Option<QueueItem<'s, V>>, KeyValError>

pub fn lock_exclusive(&self) -> Result<ExclusiveFileLock<'_, File>, KeyValError>

pub fn lock_shared(&self) -> Result<SharedFileLock<'_, File>, KeyValError>

pub fn push_front(&self, val: &V) -> Result<(), KeyValError>

pub fn resolve_entries<'s>( &'s self, keys: SliceOrBox<'s, TimeKey>, ) -> impl Iterator<Item = Result<Entry<'s, TimeKey, V>, KeyValError>> + use<'s, V>

pub fn sorted_keys( &self, wait_for_entries: bool, stop_at: Option<SystemTime>, reverse: bool, ) -> Result<Vec<TimeKey>, KeyValError>

pub fn sorted_entries<'s>( &'s self, wait_for_entries: bool, stop_at: Option<SystemTime>, reverse: bool, ) -> Result<impl Iterator<Item = Result<Entry<'s, TimeKey, V>, KeyValError>> + use<'s, V>, KeyValError>

Get all entries in order of insertion according to hires system time (assumes correct clocks!). The entries are collected at the time of this method call; entries disappearing later are skipped, but no entries inserted after this method call are returned from the iterator. Because this has O(n) cost with the number of entries, and there’s no more efficient possibility for a pop_back, this should be used and amortized by handling all entries if possible. If that’s not possible, just taking the first entry is still currently the best the underlying storage can do.

pub fn items<'s>( &'s self, opts: QueueIterationOptions, ) -> impl Iterator<Item = Result<(QueueItem<'s, V>, V), KeyValError>> + use<'s, V>

Like sorted_entries, but (1) allows to lock entries and in this case skips over entries that have been deleted by the time we have the lock, (2) allows to go on forever, (3) always retrieves the values, and offers an easy method to delete the entry as well as delete it automatically immediately.

Trait Implementations

impl<V: Debug + DeserializeOwned + Serialize> Debug for Queue<V>

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

Formats the value using the given formatter.

impl<V: PartialEq + DeserializeOwned + Serialize> PartialEq for Queue<V>

fn eq(&self, other: &Queue<V>) -> 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<V: DeserializeOwned + Serialize> StructuralPartialEq for Queue<V>