Struct BufferedSink

pub struct BufferedSink<Writer = AEADWriter, Buffer = BlockBuffer> { /* private fields */ }

Buffered object writer that supports std::io::Write.

Due to performance and storage waste considerations, this will generate a new chunk roughly about every 500kB of the input stream.

You need to take this into account when you want to create the indexes around the stream, as every ChunkPointer is 88 bytes in size, which will occupy memory and storage.

Note that you can’t std::io::Seek in this stream at this point when reading it.

Examples

use std::io::Write;
use infinitree::{*, crypto::UsernamePassword, fields::Serialized, backends::test::InMemoryBackend, object::{Stream, BufferedSink}};

let mut tree = Infinitree::<infinitree::fields::VersionedMap<String, Stream>>::empty(
    InMemoryBackend::shared(),
    UsernamePassword::with_credentials("username".to_string(), "password".to_string()).unwrap()
).unwrap();

let mut sink = BufferedSink::new(tree.storage_writer().unwrap());

sink.write(b"it's going in the sink");
tree.index().insert("message_1".to_string(), sink.finish().unwrap());
tree.commit(None);

Implementations

impl<W> BufferedSink<W>

where W: Writer,

pub fn new(writer: W) -> BufferedSink<W>

Create a new BufferedSink with the underlying Writer instance.

pub fn with_chunk_size(writer: W, chunk_size: usize) -> Self

Create a new BufferedSink with a custom chunk size

The default chunk size is 500 * 1024 bytes, which experientially is a good trade-off for various stream sizes, as it will minimize storage overhead.

impl<W, Buffer> BufferedSink<W, Buffer>

where W: Writer, Buffer: AsMut<[u8]>,

pub fn with_buffer(writer: W, buffer: Buffer) -> Result<Self>

Create a new BufferedSink with the underlying Writer and buffer.

pub fn set_chunk_size(self, size: usize) -> Result<Self>

Set the maximum size for chunks.

Errors

Will return an error if the underlying buffer is too small.

pub fn chunk_size(&self) -> usize

Return the current effective maximum chunk size.

pub fn clear(&mut self) -> Result<Stream>

Clear the internal buffer without flushing the underlying Writer.

Calling clear() over finish allows re-using the same buffer and avoids fragmenting data written to storage.

Returns the stream’s descriptor which can be freely serialized or used in an index.

pub fn finish(self) -> Result<Stream>

Finish using the BufferedSink instance, flush and close the underlying Writer.

Returns the stream’s descriptor which can be freely serialized or used in an index.

Trait Implementations

impl<W, Buffer> Write for BufferedSink<W, Buffer>

where W: Writer, Buffer: AsMut<[u8]>,

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