Trait io::BlockWriter

pub trait BlockWriter: BlockIo {
    fn write_blocks(
        &mut self,
        buffer: &[u8],
        block_offset: usize
    ) -> Result<usize, IoError>;
    fn flush(&mut self) -> Result<(), IoError>;
}

A trait that represents an I/O stream (e.g., an I/O device) that can be written to in blocks. The block size specifies the minimum granularity of each transfer, as given by the BlockIo::block_size() function.

A BlockWriter is not aware of the current block offset into the stream; thus, each write operation requires a starting offset: the number of blocks from the beginning of the I/O stream at which the write should start.

Required Methods

fn write_blocks(
    &mut self,
    buffer: &[u8],
    block_offset: usize
) -> Result<usize, IoError>

Writes blocks of data from the given buffer to this writer.

The number of blocks written is dictated by the length of the given buffer.

Arguments

• buffer: the buffer from which data will be written. The length of this buffer must be a multiple of the block size.
• block_offset: the offset in number of blocks from the beginning of this writer.

Return

If successful, returns the number of blocks written to this writer. Otherwise, returns an error.

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

Flushes this entire writer’s output stream, ensuring all contents in intermediate buffers are fully written out.

Implementations on Foreign Types

impl<W> BlockWriter for Box<W>where
    W: BlockWriter + ?Sized,

fn write_blocks(
    &mut self,
    buffer: &[u8],
    block_offset: usize
) -> Result<usize, IoError>

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

impl<W> BlockWriter for &mut Wwhere
    W: BlockWriter + ?Sized,

fn write_blocks(
    &mut self,
    buffer: &[u8],
    block_offset: usize
) -> Result<usize, IoError>

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

Implementors

impl<'io, IO, L, B> BlockWriter for &LockableIo<'io, IO, L, B>where
    IO: BlockWriter + 'io + ?Sized,
    L: for<'a> Lockable<'a, IO> + ?Sized,
    B: Borrow<L>,

impl<'io, IO, L, B> BlockWriter for LockableIo<'io, IO, L, B>where
    IO: BlockWriter + 'io + ?Sized,
    L: for<'a> Lockable<'a, IO> + ?Sized,
    B: Borrow<L>,

impl<IO> BlockWriter for ReaderWriter<IO>where
    IO: BlockWriter,

impl<IO> BlockWriter for Writer<IO>where
    IO: BlockWriter,

impl<RW> BlockWriter for ByteReaderWriterWrapper<RW>where
    RW: BlockReader + BlockWriter,

impl<RW> BlockWriter for ByteWriterWrapper<RW>where
    RW: BlockReader + BlockWriter,