Struct fuse_backend_rs::transport::FuseDevWriter

pub struct FuseDevWriter<'a, S: BitmapSlice = ()> { /* private fields */ }

Writer to send FUSE reply to the FUSE driver.

There are a few special properties to follow:

1. A fuse device request MUST be written to the fuse device in one shot.
2. If the writer is split, a final commit() MUST be called to issue the device write operation.
3. Concurrency, caller should not write to the writer concurrently.

Implementations

impl<'a, S: BitmapSlice + Default> FuseDevWriter<'a, S>

pub fn new(fd: RawFd, data_buf: &'a mut [u8]) -> Result<FuseDevWriter<'a, S>>

Construct a new Writer.

impl<'a, S: BitmapSlice> FuseDevWriter<'a, S>

pub fn split_at(&mut self, offset: usize) -> Result<FuseDevWriter<'a, S>>

Split the Writer at the given offset.

After the split, self will be able to write up to offset bytes while the returned Writer can write up to available_bytes() - offset bytes. Returns an error if offset > self.available_bytes().

pub fn commit(&mut self, other: Option<&Writer<'a, S>>) -> Result<usize>

Compose the FUSE reply message and send the message to /dev/fuse.

pub fn bytes_written(&self) -> usize

Return number of bytes already written to the internal buffer.

pub fn available_bytes(&self) -> usize

Return number of bytes available for writing.

pub fn write_obj<T: ByteValued>(&mut self, val: T) -> Result<()>

Write an object to the writer.

pub fn write_from<F: FileReadWriteVolatile>( &mut self, src: F, count: usize, ) -> Result<usize>

Write data to the writer from a file descriptor.

Return the number of bytes written to the writer.

pub fn write_from_at<F: FileReadWriteVolatile>( &mut self, src: F, count: usize, off: u64, ) -> Result<usize>

Write data to the writer from a File at offset off. Return the number of bytes written to the writer.

pub fn write_all_from<F: FileReadWriteVolatile>( &mut self, src: F, count: usize, ) -> Result<()>

Write all data to the writer from a file descriptor.

Trait Implementations

impl<'a, S: Debug + BitmapSlice> Debug for FuseDevWriter<'a, S>

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

Formats the value using the given formatter.

impl<'a, S: BitmapSlice> From<FuseDevWriter<'a, S>> for Writer<'a, S>

fn from(w: FuseDevWriter<'a, S>) -> Self

Converts to this type from the input type.

impl<'a, S: PartialEq + BitmapSlice> PartialEq for FuseDevWriter<'a, S>

fn eq(&self, other: &FuseDevWriter<'a, S>) -> 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<'a, S: BitmapSlice> Write for FuseDevWriter<'a, S>

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

As this writer can associate multiple writers by splitting, flush() can’t flush them all. Disable it!

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

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

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 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, fmt: 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<'a, S: Eq + BitmapSlice> Eq for FuseDevWriter<'a, S>

impl<'a, S: BitmapSlice> StructuralPartialEq for FuseDevWriter<'a, S>