Struct infinitree::object::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::{Infinitree, Key, fields::Serialized, backends::test::InMemoryBackend, object::{BufferedSink, Stream}};

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

let mut sink = BufferedSink::new(tree.object_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.

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

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

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

Flush 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

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