Struct CFile

pub struct CFile(/* private fields */);

A reference to an open stream on the filesystem.

An instance of a CFile can be read and/or written depending on what modes it was opened with. CFile also implement Seek to alter the logical cursor that the file contains internally.

Implementations

impl CFile

pub fn fdopen<S: AsRef<str>>(fd: RawFd, mode: S) -> Result<CFile>

impl CFile

pub fn unlocked(self) -> Unlocked

Returns a unlocked CFile stream except that they do not use locking.

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 AsMut<CFileRef> for CFile

fn as_mut(&mut self) -> &mut CFileRef

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<CFileRef> for CFile

fn as_ref(&self) -> &CFileRef

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<CFileRef> for CFile

fn borrow(&self) -> &CFileRef

Immutably borrows from an owned value.

impl BorrowMut<CFileRef> for CFile

fn borrow_mut(&mut self) -> &mut CFileRef

Mutably borrows from an owned value.

impl Deref for CFile

type Target = CFileRef

The resulting type after dereferencing.

fn deref(&self) -> &CFileRef

Dereferences the value.

impl DerefMut for CFile

fn deref_mut(&mut self) -> &mut CFileRef

Mutably dereferences the value.

impl Drop for CFile

fn drop(&mut self)

Executes the destructor for this type.

impl ForeignType for CFile

type CType = FILE

The raw C type.

type Ref = CFileRef

The type representing a reference to this type.

unsafe fn from_ptr(ptr: *mut FILE) -> CFile

Constructs an instance of this type from its raw type.

fn as_ptr(&self) -> *mut FILE

Returns a raw pointer to the wrapped value.

fn into_ptr(self) -> *mut Self::CType

Consumes the wrapper and returns the raw pointer.

impl IntoRawFd for CFile

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl Read for CFile

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, Error>

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.

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

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

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

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

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl Seek for CFile

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

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

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

Rewind to the beginning of a stream.

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

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

Returns the length of this stream (in bytes).

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

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

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl Write for CFile

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

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

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

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

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

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 Writer 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, args: Arguments<'_>) -> Result<(), Error>

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

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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl Send for CFile