Struct IOStatWrapper 

pub struct IOStatWrapper<T, C> { /* private fields */ }

A wrapper around an IO object that tracks operations and statistics.

Implementations

impl<T, C> IOStatWrapper<T, C>

where C: Default + Extend<IopInfoPair>,

pub fn new(obj: T, start_seek_pos: u64) -> IOStatWrapper<T, C>

Create a new IOStatWrapper with a manually given seek position. Detecting the seek position automatically is not possible without specialization.

Examples found in repository

examples/bufread_reduced_read_count.rs (line 8)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    for byte in (&mut instrumented_buf_file).bytes() {
        xor_result ^= byte.unwrap();
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
}

examples/bufread_assert_stream_position.rs (line 8)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.stream_position().unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

examples/bufread_assert_seek_zero.rs (line 8)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.seek(SeekFrom::Current(0)).unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

pub fn into_inner(self) -> T

Extract the original I/O object.

pub fn iop_log(&self) -> &C

Get the I/O operation log containing operations and their results.

impl<T: Read, C> IOStatWrapper<T, C>

pub fn read_call_counter(&self) -> &SuccessFailureCounter<u64>

Returns the number of times Read::read() was invoked.

Examples found in repository

examples/bufread_reduced_read_count.rs (line 21)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    for byte in (&mut instrumented_buf_file).bytes() {
        xor_result ^= byte.unwrap();
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
}

examples/bufread_assert_stream_position.rs (line 28)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.stream_position().unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

examples/bufread_assert_seek_zero.rs (line 28)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.seek(SeekFrom::Current(0)).unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

pub fn read_byte_counter(&self) -> usize

Returns the total number of bytes read.

impl<T: Seek, C> IOStatWrapper<T, C>

pub fn seek_call_counter(&self) -> &SuccessFailureCounter<u64>

Returns the number of times Seek::seek() was invoked.

Examples found in repository

examples/bufread_assert_stream_position.rs (line 30)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.stream_position().unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

examples/bufread_assert_seek_zero.rs (line 30)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.seek(SeekFrom::Current(0)).unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

pub fn seek_pos(&self) -> u64

Get the current seek position without doing an actual seek operation.

This is accomplished by storing a separate position integer. When debug assertions are on we assert after every seek operation that the cursor is where we expect it to be.

Examples found in repository

examples/bufread_assert_stream_position.rs (line 21)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.stream_position().unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

examples/bufread_assert_seek_zero.rs (line 21)

fn main() {
    let file_obj = File::open("Cargo.toml").unwrap();
    let mut instrumented_raw_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(file_obj, 0);
    let buffered_io = BufReader::new(&mut instrumented_raw_file);
    let mut instrumented_buf_file = IOStatWrapper::<_, Vec<IopInfoPair>>::new(buffered_io, 0);

    // Do something so that the loop doesn't get optimized out
    let mut xor_result: u8 = 0x00;
    let mut read_buf: [u8; 1] = [0x00; 1];
    loop {
        let bytes_read = instrumented_buf_file.read(&mut read_buf).unwrap();
        if bytes_read == 0 {
            break;
        }
        xor_result ^= read_buf[0];
        assert_eq!(instrumented_buf_file.seek_pos(),
            instrumented_buf_file.seek(SeekFrom::Current(0)).unwrap());
    }
    println!("XOR of all bytes in Cargo.toml is {:#x}", xor_result);

    // Demonstrate how BufReader reduces the number of read calls
    println!("Buffered read was called successfully {} times",
        instrumented_buf_file.read_call_counter().success_ctr());
    println!("Buffered seek was called successfully {} times",
        instrumented_buf_file.seek_call_counter().success_ctr());
    println!("Inner read was called successfully {} times",
        instrumented_raw_file.read_call_counter().success_ctr());
    println!("Inner seek was called successfully {} times",
        instrumented_raw_file.seek_call_counter().success_ctr());
}

impl<T: Write, C> IOStatWrapper<T, C>

pub fn write_call_counter(&self) -> &SuccessFailureCounter<u64>

Returns the number of times Write::write() was invoked.

pub fn write_flush_counter(&self) -> &SuccessFailureCounter<u64>

Returns the number of times Write::flush() was invoked.

pub fn write_byte_counter(&self) -> usize

Trait Implementations

impl<T: Debug, C: Debug> Debug for IOStatWrapper<T, C>

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

Formats the value using the given formatter.

impl<T: Read, C: Extend<IopInfoPair>> Read for IOStatWrapper<T, C>

We wrap most methods of Read, including provided ones, and pass calls through to the inner I/O object. The I/O operation log and statistics are only explicitly updated in the Read::read() function, as it is expected that the other methods are implemented with it. Notably, we do not passthrough Read::bytes(), Read::chain(), and Read::take() as the structs they return have private implementation details that we need to see to have correct type generics. However, for this reason, we do not expect other Read implementations to have their own implementations either, so this shouldn’t be an issue.

fn read(&mut self, buf: &mut [u8]) -> IOResult<usize>

Passthrough for the inner_io read call that increments a call counter and appends a IopResults::Read object to the log.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> IOResult<usize>

Like read, except that it reads into a slice of buffers.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> IOResult<usize>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> IOResult<usize>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> IOResult<()>

Reads the exact number of bytes required to fill buf.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<T: Seek, C: Extend<IopInfoPair>> Seek for IOStatWrapper<T, C>

We wrap all methods of Seek, including provided ones, and pass calls through to the inner I/O object. The I/O operation log and statistics are only explicitly updated in the Seek::seek() function, as it is expected that the other methods are implemented with it.

fn seek(&mut self, pos: SeekFrom) -> IOResult<u64>

Passthrough for the inner_io seek call that increments a call counter and appends a IopResults::Seek object to the log.

fn rewind(&mut self) -> IOResult<()>

Rewind to the beginning of a stream.

fn stream_position(&mut self) -> IOResult<u64>

Returns the current seek position from the start of the stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl<T: Write, C: Extend<IopInfoPair>> Write for IOStatWrapper<T, C>

We wrap all methods of Write, including provided ones, and pass calls through to the inner I/O object. The I/O operation log and statistics are explicitly updated in the Write::write() and Write::flush() functions, as it is expected that the other methods are implemented with them.

fn write(&mut self, buf: &[u8]) -> IOResult<usize>

Passthrough for the inner_io write call that increments a call counter and appends a IopResults::Write object to the log.

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

Passthrough for the inner_io write call that increments a call counter and appends a IopResults::Flush object to the log.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> IOResult<usize>

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> IOResult<()>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> IOResult<()>

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.

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