Struct cookie_factory::WriteCounter

pub struct WriteCounter<W>(_, _);

Wrapper around Write that counts how much data was written

This can be used to keep track how much data was actually written by serializing functions, for example

use cookie_factory::{WriteCounter, string};

let mut buf = [0u8; 100];

{
    let mut writer = WriteCounter::new(&mut buf[..]);
    writer = string("abcd")(writer).unwrap();
    assert_eq!(writer.position(), 4);
    let (buf, len) = writer.into_inner();
    assert_eq!(buf.len(), 96);
    assert_eq!(len, 4);
}

assert_eq!(&buf[..4], &b"abcd"[..]);

For byte slices std::io::Cursor provides more features and allows to retrieve the original slice

#[cfg(feature = "std")]
use std::io::Cursor;
#[cfg(not(feature = "std"))]
use cookie_factory::lib::std::io::{Cursor, Write};

use cookie_factory::string;

let mut buf = [0u8; 100];

let mut cursor = Cursor::new(&mut buf[..]);
cursor = string("abcd")(cursor).unwrap();
assert_eq!(cursor.position(), 4);
let buf = cursor.into_inner();

assert_eq!(&buf[..4], &b"abcd"[..]);

Methods

impl<W: Write> WriteCounter<W>

pub fn new(w: W) -> Self

Create a new WriteCounter around w

pub fn position(&self) -> u64

Returns the amount of bytes written so far

pub fn into_inner(self) -> (W, u64)

Consumes the WriteCounter and returns the contained Write and the amount of bytes written

Trait Implementations

impl<W: Write> Write for WriteCounter<W>

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 write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

Important traits for &'_ mut W

impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.