Struct positioned_io::ByteIo

pub struct ByteIo<I, E: ByteOrder> { /* fields omitted */ }

Read or write with a given inherent byte-order.

If you know that you'll always be using a single endianness, an instance of ByteIo will allow you to omit the endian specifier on every read or write.

Examples

use positioned_io::{ByteIo, WriteInt};

let mut buf = [0; 8];
{
    let mut io : ByteIo<_, BigEndian> = ByteIo::new(buf.as_mut());
    // All writes will automatically be BigEndian.
    try!(io.write_u16(300));
    try!(io.write_u32(1_000_000));
    try!(io.write_i16(-1));
 }
assert_eq!(buf, [1, 44, 0, 15, 66, 64, 255, 255]);

Methods

impl<I, E> ByteIo<I, E> where
    E: ByteOrder, 

fn new(io: I) -> Self

Create a new ByteIo from some sort of reader or writer.

You will need to specify the byte-order when creating a ByteIo.

Examples

use positioned_io::ByteIo;

let buf = [0; 10];
// Add a type specifier for the byte order.
let io : ByteIo<_, BigEndian> = ByteIo::new(buf.as_ref());

Trait Implementations

impl<I, E> Deref for ByteIo<I, E> where
    E: ByteOrder, 

type Target = I

The resulting type after dereferencing

fn deref(&self) -> &I

The method called to dereference a value

impl<I, E> DerefMut for ByteIo<I, E> where
    E: ByteOrder, 

fn deref_mut(&mut self) -> &mut I

The method called to mutably dereference a value

impl<I, E: ByteOrder> Read for ByteIo<I, E> where
    I: Read, 

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

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

Creates an adaptor which will chain this stream with another.

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

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

impl<I, E: ByteOrder> Write for ByteIo<I, E> where
    I: Write, 

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

Write a buffer into this object, 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_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

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" adaptor for this instance of Write.

impl<I, E: ByteOrder> ReadAt for ByteIo<I, E> where
    I: ReadAt, 

fn read_at(&self, pos: u64, buf: &mut [u8]) -> Result<usize>

Read bytes from an offset in this source into a buffer, returning how many bytes were read.

fn read_exact_at(&self, pos: u64, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf, from an offset.

impl<I, E: ByteOrder> WriteAt for ByteIo<I, E> where
    I: WriteAt, 

fn write_at(&mut self, pos: u64, buf: &[u8]) -> Result<usize>

Write a buffer at an offset, returning the number of bytes written.

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

Flush this writer, ensuring that any buffered data is written.

fn write_all_at(&mut self, pos: u64, buf: &[u8]) -> Result<()>

Write a complete buffer at an offset.

impl<I, E: ByteOrder> ReadInt for ByteIo<I, E> where
    I: Read, 

fn read_u8(&mut self) -> Result<u8>

Reads an unsigned 8-bit integer.

fn read_i8(&mut self) -> Result<i8>

Reads a signed 8-bit integer.

fn read_u16(&mut self) -> Result<u16>

Reads an unsigned 8-bit integer.

fn read_i16(&mut self) -> Result<i16>

Reads a signed 16-bit integer.

fn read_u32(&mut self) -> Result<u32>

Reads an unsigned 32-bit integer.

fn read_i32(&mut self) -> Result<i32>

Reads a signed 32-bit integer.

fn read_u64(&mut self) -> Result<u64>

Reads an unsigned 64-bit integer.

fn read_i64(&mut self) -> Result<i64>

Reads a signed 64-bit integer.

fn read_uint(&mut self, nbytes: usize) -> Result<u64>

Reads an unsigned nbytes-bit integer.

fn read_int(&mut self, nbytes: usize) -> Result<i64>

Reads a signed nbytes-bit integer.

fn read_f32(&mut self) -> Result<f32>

Reads a single-precision floating point number.

fn read_f64(&mut self) -> Result<f64>

Reads a double-precision floating point number.

impl<I, E: ByteOrder> WriteInt for ByteIo<I, E> where
    I: Write, 

fn write_u8(&mut self, n: u8) -> Result<()>

Writes an unsigned 8-bit integer.

fn write_i8(&mut self, n: i8) -> Result<()>

Writes a signed 8-bit integer.

fn write_u16(&mut self, n: u16) -> Result<()>

Writes an unsigned 16-bit integer.

fn write_i16(&mut self, n: i16) -> Result<()>

Writes a signed 16-bit integer.

fn write_u32(&mut self, n: u32) -> Result<()>

Writes an unsigned 32-bit integer.

fn write_i32(&mut self, n: i32) -> Result<()>

Writes a signed 32-bit integer.

fn write_u64(&mut self, n: u64) -> Result<()>

Writes an unsigned 64-bit integer.

fn write_i64(&mut self, n: i64) -> Result<()>

Writes a signed 64-bit integer.

fn write_uint(&mut self, n: u64, nbytes: usize) -> Result<()>

Writes an unsigned nbytes-bit integer.

fn write_int(&mut self, n: i64, nbytes: usize) -> Result<()>

Writes a signed nbytes-bit integer.

fn write_f32(&mut self, n: f32) -> Result<()>

Writes a single-precision floating point number.

fn write_f64(&mut self, n: f64) -> Result<()>

Writes a double-precision floating point number.

impl<I, E: ByteOrder> ReadIntAt for ByteIo<I, E> where
    I: ReadAt, 

fn read_u8_at(&self, pos: u64) -> Result<u8>

Reads an unsigned 8-bit integer at an offset.

fn read_i8_at(&self, pos: u64) -> Result<i8>

Reads a signed 8-bit integer at an offset.

fn read_u16_at(&self, pos: u64) -> Result<u16>

Reads an unsigned 16-bit integer at an offset.

fn read_i16_at(&self, pos: u64) -> Result<i16>

Reads a signed 16-bit integer at an offset.

fn read_u32_at(&self, pos: u64) -> Result<u32>

Reads an unsigned 32-bit integer at an offset.

fn read_i32_at(&self, pos: u64) -> Result<i32>

Reads a signed 32-bit integer at an offset.

fn read_u64_at(&self, pos: u64) -> Result<u64>

Reads an unsigned 64-bit integer at an offset.

fn read_i64_at(&self, pos: u64) -> Result<i64>

Reads a signed 64-bit integer at an offset.

fn read_uint_at(&self, pos: u64, nbytes: usize) -> Result<u64>

Reads an unsigned nbytes-bit integer at an offset.

fn read_int_at(&self, pos: u64, nbytes: usize) -> Result<i64>

Reads a signed nbytes-bit integer at an offset.

fn read_f32_at(&self, pos: u64) -> Result<f32>

Reads a single-precision floating point number at an offset.

fn read_f64_at(&self, pos: u64) -> Result<f64>

Reads a double-precision floating point number at an offset.

impl<I, E: ByteOrder> WriteIntAt for ByteIo<I, E> where
    I: WriteAt, 

fn write_u8_at(&mut self, pos: u64, n: u8) -> Result<()>

Writes an unsigned 8-bit integer to an offset.

fn write_i8_at(&mut self, pos: u64, n: i8) -> Result<()>

Writes a signed 8-bit integer to an offset.

fn write_u16_at(&mut self, pos: u64, n: u16) -> Result<()>

Writes an unsigned 16-bit integer to an offset.

fn write_i16_at(&mut self, pos: u64, n: i16) -> Result<()>

Writes a signed 16-bit integer to an offset.

fn write_u32_at(&mut self, pos: u64, n: u32) -> Result<()>

Writes an unsigned 32-bit integer to an offset.

fn write_i32_at(&mut self, pos: u64, n: i32) -> Result<()>

Writes a signed 32-bit integer to an offset.

fn write_u64_at(&mut self, pos: u64, n: u64) -> Result<()>

Writes an unsigned 64-bit integer to an offset.

fn write_i64_at(&mut self, pos: u64, n: i64) -> Result<()>

Writes a signed 64-bit integer to an offset.

fn write_uint_at(&mut self, pos: u64, n: u64, nbytes: usize) -> Result<()>

Writes an unsigned nbytes-bit integer to an offset.

fn write_int_at(&mut self, pos: u64, n: i64, nbytes: usize) -> Result<()>

Writes a signed nbytes-bit integer to an offset.

fn write_f32_at(&mut self, pos: u64, n: f32) -> Result<()>

Writes a single-precision floating point number to an offset.

fn write_f64_at(&mut self, pos: u64, n: f64) -> Result<()>

Writes a double-precision floating point number to an offset.