impl<T: Flockable> Flock<T>

fn lock(t: T, args: FlockArg) -> Result<Self, (T, Errno)>

Obtain a/an flock.

Example

# use std::io::Write;
# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
# fn do_stuff(file: File) {
  let mut file = match Flock::lock(file, FlockArg::LockExclusive) {
      Ok(l) => l,
      Err(_) => return,
  };

  // Do stuff
  let data = "Foo bar";
  _ = file.write(data.as_bytes());
  _ = file.sync_data();
# }

fn unlock(self: Self) -> Result<T, (Self, Errno)>

Remove the lock and return the object wrapped within.

Example

# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
fn do_stuff(file: File) -> nix::Result<()> {
    let mut lock = match Flock::lock(file, FlockArg::LockExclusive) {
        Ok(l) => l,
        Err((_,e)) => return Err(e),
    };

    // Do critical section

    // Unlock
    let file = match lock.unlock() {
        Ok(f) => f,
        Err((_, e)) => return Err(e),
    };

    // Do anything else

    Ok(())
}

fn relock(self: &Self, arg: FlockArg) -> Result<()>

Relock the file. This can upgrade or downgrade the lock type.

Example

# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
# use tempfile::tempfile;
let f: std::fs::File = tempfile().unwrap();
let locked_file = Flock::lock(f, FlockArg::LockExclusive).unwrap();
// Do stuff, then downgrade the lock
locked_file.relock(FlockArg::LockShared).unwrap();

impl<P, T> Receiver for Flock<T>

impl<T> Any for Flock<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Flock<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Flock<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> Freeze for Flock<T>

impl<T> From for Flock<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> RefUnwindSafe for Flock<T>

impl<T> Send for Flock<T>

impl<T> Sync for Flock<T>

impl<T> Unpin for Flock<T>

impl<T> UnsafeUnpin for Flock<T>

impl<T> UnwindSafe for Flock<T>

impl<T, U> Into for Flock<T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Flock<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Flock<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: $crate::fmt::Debug + Flockable> Debug for Flock<T>

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

impl<T: Flockable> Deref for Flock<T>

fn deref(self: &Self) -> &<Self as >::Target

impl<T: Flockable> DerefMut for Flock<T>

fn deref_mut(self: &mut Self) -> &mut <Self as >::Target

impl<T: Flockable> Drop for Flock<T>

fn drop(self: &mut Self)