Enum file_guard::Lock

pub enum Lock {
    Shared,
    Exclusive,
}

The type of a lock operation.

This is used to specify the desired lock type when used with lock() and try_lock(), and it is the successful result type returned by lock_any().

Variants

Shared

A shared lock may be concurrently held by multiple processes while preventing future exclusive locks its lifetime.

The shared lock type cannot be obtained while an exclusive lock is held by another process. When successful, a shared lock guarantees that only one or more shared locks are concurrently held, and that no exclusive locks are held.

This lock type–often referred to as a read lock–may be used as a means of signaling read integrity. When used cooperatively, they ensure no exclusive lock is held, and thus, no other process may be writing to a shared resource.

Exclusive

An exclusive lock may only be held by a single process.

The exclusive lock type can neither be obtained while any shared locks are held or while any other exclusive locks are held. This linearizes the sequence of processes attempting to acquire an exclusive lock.

This lock type–also known as a write lock–may be used as a means of ensuring write exclusivity. In a cooperative locking environment, all access to a shared resource is halted until the exlusive lock is released.

Trait Implementations

impl Clone for Lock

fn clone(&self) -> Lock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Lock

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

Formats the value using the given formatter.

impl PartialEq for Lock

fn eq(&self, other: &Lock) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Lock

impl StructuralPartialEq for Lock