Struct FileLock

pub struct FileLock<'a>(/* private fields */);

A locked reference to the CFile stream.

Methods from Deref<Target = CFileRef>

pub fn reopen(&self, filename: &str, mode: &str) -> Result<CFile>

opens the file whose name is the string pointed to by filename and associates the stream pointed to by stream with it.

The original stream (if it exists) is closed. The mode argument is used just as in the open() function.

pub fn bytes(&self) -> Bytes<'_>

An iterator over the bytes of a *FILE stream.

pub fn lines(&self) -> Lines<Bytes<'_>>

An iterator over the lines of a *FILE stream.

pub fn lock(&mut self) -> FileLock<'_>

acquires an exclusive lock on the specified object.

If another thread has already locked the object, will block until the lock is released.

Examples

use std::io::Write;
use cfile::tmpfile;

let mut f = tmpfile().unwrap();
let mut l = f.lock();

assert_eq!(l.write(b"test").unwrap(), 4);

pub fn try_lock(&mut self) -> Option<FileLock<'_>>

a non-blocking version of lock();

if the lock cannot be acquired immediately, try_lock() returns None instead of blocking.

Examples

use std::io::{Read, Write, BufRead, BufReader, Seek, SeekFrom};
use cfile::tmpfile;

let mut f = tmpfile().unwrap();

if let Some(mut c) = f.try_lock() {
    assert_eq!(c.write(b"test").unwrap(), 4);
}

assert_eq!(f.seek(SeekFrom::Start(0)).unwrap(), 0); // seek to the beginning of stream

let mut r = BufReader::new(f);
let mut s = String::new();
assert_eq!(r.read_line(&mut s).unwrap(), 4); // read back the text
assert_eq!(s, "test");

Trait Implementations

impl<'a> Deref for FileLock<'a>

type Target = CFileRef

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a> DerefMut for FileLock<'a>

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

Mutably dereferences the value.

impl<'a> Drop for FileLock<'a>

fn drop(&mut self)

Executes the destructor for this type.