Struct file_locker::FileLock

pub struct FileLock {
    pub file: File,
}

Represents the actually locked file

Fields

file: File

the std::fs::File of the file that's locked

Implementations

impl FileLock

pub fn new<T: AsRef<Path>>(file_path: T) -> FileLockBuilder<T>

Create a FileLockBuilder

blocking and writeable default to false

Examples

use file_locker::FileLock;
use std::io::prelude::*;
use std::io::Result;

fn main() -> Result<()> {
    let mut filelock = FileLock::new("myfile.txt")
                     .writeable(true)
                     .blocking(true)
                     .lock()?;

    filelock.file.write_all(b"Hello, world")?;
    Ok(())
}

pub fn lock(
    file_path: impl AsRef<Path>,
    blocking: bool,
    writeable: bool
) -> Result<FileLock>

Try to lock the specified file

Parameters

• filename is the path of the file we want to lock on

• is_blocking is a flag to indicate if we should block if it's already locked

If set, this call will block until the lock can be obtained.
If not set, this call will return immediately, giving an error if it would block

• is_writable is a flag to indicate if we want to lock for writing

Examples

use file_locker::FileLock;
use std::io::prelude::*;
use std::io::Result;

fn main() -> Result<()> {
    let mut filelock = FileLock::lock("myfile.txt", false, false)?;

    let mut buf = String::new();
    filelock.file.read_to_string(&mut buf)?;
    Ok(())
}

pub fn unlock(&self) -> Result<()>

Unlock our locked file

Note: This method is optional as the file lock will be unlocked automatically when dropped

Examples

use file_locker::FileLock;
use std::io::prelude::*;
use std::io::Result;

fn main() -> Result<()> {
    let mut filelock = FileLock::new("myfile.txt")
                     .writeable(true)
                     .blocking(true)
                     .lock()?;

    filelock.file.write_all(b"Hello, world")?;

    filelock.unlock()?;
    Ok(())
}

Trait Implementations

impl AsRawFd for FileLock

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for FileLock

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

Formats the value using the given formatter.

impl Drop for FileLock

fn drop(&mut self)

Executes the destructor for this type.

impl FileExt for FileLock

fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize>

Reads a number of bytes starting from a given offset.

fn write_at(&self, buf: &[u8], offset: u64) -> Result<usize>

Writes a number of bytes starting from a given offset.

fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<(), Error>

Reads the exact number of byte required to fill buf from the given offset.

fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<(), Error>

Attempts to write an entire buffer starting from a given offset.

impl Read for FileLock

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl Seek for FileLock

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬 This is a nightly-only experimental API. (seek_convenience)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

🔬 This is a nightly-only experimental API. (seek_convenience)

Returns the current seek position from the start of the stream.

impl Write for FileLock

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.