Crate read_buffer

This crate provides ReadBuffer, a wrapper to safely read into a buffer from a Read.

Motivation

With the default way of reading into a buffer using Read::read like this:

use std::io::Read;
 
let data = [1, 2, 3, 4];
let mut reader = &data[..]; // Read is implemented for &[u8]
let mut buffer = [0; 16];
 
let length = reader.read(&mut buffer)?;
assert_eq!(buffer[..length], [1, 2, 3, 4]);

there’s nothing stopping you from accessing more data of the buffer than what was read or even outright ignoring the Result of Read::read:

use std::io::Read;
 
let data = [8, 8, 8, 8];
let mut reader = &data[..];
let mut buffer = [0; 8];
 
// Ignoring the result of Read::read which might fail
reader.read(&mut buffer);
 
// Reading too much data
assert_eq!(buffer, [8, 8, 8, 8, 0, 0, 0, 0]);
 
let data = [1, 2, 3];
let mut reader = &data[..];
 
reader.read(&mut buffer);
 
// Reading garbage data from previous call to Read::read
assert_eq!(buffer[..4], [1, 2, 3, 8]);

ReadBuffer provides a wrapper that only lets you access the data that was actually read, and forces you to check the Result before accessing the data.

Examples

use read_buffer::ReadBuffer;
 
let data = [8, 8, 8, 8];
let mut reader = &data[..];
let mut buffer: ReadBuffer<8> = ReadBuffer::new();
 
// We are forced to check the Result of read_from to access the data we read
let read_data = buffer.read_from(&mut reader)?;
 
// read_data is a slice over only the data we actually read,
// trying to access the buffer past that point would panic
let eight = read_data[3];
// let zero = read_data[4]; would panic
 
assert_eq!(eight, 8);
assert_eq!(read_data, [8, 8, 8, 8]);
 
// We can reuse the same buffer for the next read, just as with Read::read
 
let data = [1, 2, 3];
let mut reader = &data[..];
 
let read_data = buffer.read_from(&mut reader)?;
 
// Again, we get a slice over only the data that was just read,
// trying to read garbage data from the previous call to read_from
// here would panic
let three = read_data[2];
// let eight = read_data[3]; would panic
 
assert_eq!(three, 3);
assert_eq!(read_data, [1, 2, 3]);

Structs

• ReadBuffer
  A buffer to read into from a Read and safely access the read data.