Enum LockType 

pub enum LockType {
    Shared,
    Exclusive,
}

Type of file lock.

Used with FsLock::lock to request either shared or exclusive access to a file.

Variants

Variant	Behavior
Shared	Multiple readers allowed simultaneously
Exclusive	Single writer, no other access

Lock Compatibility

Held Lock	Shared Request	Exclusive Request
None	✓ Granted	✓ Granted
Shared	✓ Granted	✗ Blocked
Exclusive	✗ Blocked	✗ Blocked

Example

use anyfs_backend::{FsLock, FsHandles, OpenFlags, LockType};
use std::path::Path;

// Generic function that works with any FsHandles + FsLock implementation
fn safe_read<B: FsHandles + FsLock>(fs: &B) -> Result<(), anyfs_backend::FsError> {
    let handle = fs.open(Path::new("/data.txt"), OpenFlags::READ)?;
     
    // Shared lock allows concurrent readers
    fs.lock(handle, LockType::Shared)?;
     
    // ... read data ...
     
    fs.unlock(handle)?;
    fs.close(handle)?;
    Ok(())
}

Variants

Shared

Shared lock — multiple readers allowed simultaneously.

Use when reading data that shouldn’t change during the read. Multiple processes can hold shared locks on the same file.

Exclusive

Exclusive lock — single writer, blocks all other access.

Use when modifying data. Only one process can hold an exclusive lock, and it blocks all shared lock requests.

Trait Implementations

impl Clone for LockType

fn clone(&self) -> LockType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LockType

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

Formats the value using the given formatter.

impl Hash for LockType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LockType

fn eq(&self, other: &LockType) -> 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 Copy for LockType

impl Eq for LockType

impl StructuralPartialEq for LockType