Struct BufferedBuilder

pub struct BufferedBuilder<B>
where
    B: RwBuilder,
{ /* private fields */ }

Type returned by the buffered function on the RwBuilder trait. It is itself an RwBuilder so can be chained further.

Implementations

impl<B> Builder<B>

where B: RwBuilder,

pub const fn new(builder: B) -> Self

Factory function to wrap an inner builder

Trait Implementations

impl<B> Debug for Builder<B>

where B: RwBuilder + Debug,

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

Formats the value using the given formatter.

impl<B> RwBuilder for Builder<B>

where B: RwBuilder, B::Reader: Read, B::Writer: Write,

type Reader = BufReader<<B as RwBuilder>::Reader>

The reader type that will be constructed by the reader function

type Writer = BufWriter<<B as RwBuilder>::Writer>

The writer type that will be constructed by the reader function

fn reader(&self) -> Result<Self::Reader>

Construct a reader from this builder

fn writer(&self) -> Result<Self::Writer>

Construct a writer from this builder

fn buffered(self) -> BufferedBuilder<Self>

Buffers the underlying readers and writers by wrapping them in a BufReader or BufWriter

fn string(self) -> Builder<Self>

Sink that provides a bridge between String instances and underlying readers and writers.

fn bincode(self) -> BincodeBuilder<Self>

Sink that provides a bridge between serde and the underlying readers and writer by transforming from and to bincode.

fn chacha20( self, key: ChaCha20Key, nonce: ChaCha20Nonce, ) -> ChaCha20Builder<Self>

Transformation that decrypts while reading and encrypts while writing using the chacha20 cipher

fn salsa20(self, key: Salsa20Key, nonce: Salsa20Nonce) -> Salsa20Builder<Self>

Transformation that decrypts while reading and encrypts while writing using the salsa20 cipher

fn crc(self) -> CrcBuilder<Self>

Non-commutative transformation that hashes using the CRC algorithm

fn deflate(self, compression: Compression) -> CompressionBuilder<Self, Deflate>

Transformation that decompresses while reading and compresses while writing using the Deflate algorithm

fn gz(self, compression: Compression) -> CompressionBuilder<Self, Gz>

Transformation that decompresses while reading and compresses while writing using the Gz algorithm

fn zlib(self, compression: Compression) -> CompressionBuilder<Self, Zlib>

Transformation that decompresses while reading and compresses while writing using the Zlib algorithm