Struct KeyVal

pub struct KeyVal<K: AsKey, V: DeserializeOwned + Serialize> {
    pub config: KeyValConfig,
    pub base_dir: PathBuf,
    /* private fields */
}

Fields

config: KeyValConfig

base_dir: PathBuf

Implementations

impl<K: AsKey, V: DeserializeOwned + Serialize> KeyVal<K, V>

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

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

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

pub fn insert( &self, key: &K, val: &V, exclusive: bool, ) -> Result<(), KeyValError>

where K: Debug,

Insert a mapping; if exclusive is true, give an error if key is already in the map (otherwise the previous value is silently overwritten).

pub fn delete(&self, key: &K) -> Result<bool, KeyValError>

Returns whether an entry was actually deleted (false means that no entry for key existed)

pub fn entry_opt(&self, key: &K) -> Result<Option<Entry<'_, K, V>>, KeyValError>

Get access to an entry, if it exists. Note: does not lock, and on Windows might possibly deadlock with the rename calls of insert? Only tested on Linux (and macOS?)

pub fn get(&self, key: &K) -> Result<Option<V>, KeyValError>

Note: does not lock, and on Windows might possibly deadlock with the rename calls of insert! Only tested on Linux (and macOS?)

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

Stops waiting at stop_at if given. Returns true if it found an entry, false if it timed out.

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

Get all the keys contained in the map. Their order is not defined. Note that the returned entries may not exist any more by the time your code looks at them, since exclusivity can’t be statically ensured, and taking a lock for the iterator’s life time seems excessive. If wait_for_entries is true, blocks until entries exist (but note that with concurrent deletions, by the time the entries are read, they may be gone again–the returned sequence might still be empty).

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

where K: Ord,

Sorted output of keys().

Trait Implementations

impl<K: Debug + AsKey, V: Debug + DeserializeOwned + Serialize> Debug for KeyVal<K, V>

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

Formats the value using the given formatter.

impl<K: AsKey, V: DeserializeOwned + Serialize> PartialEq for KeyVal<K, V>

fn eq(&self, other: &Self) -> 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.