Struct positioned_io::ByteIo

pub struct ByteIo<I, E: ByteOrder> {
    // some 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;

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());

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

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

Reads an unsigned 16-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> ByteIo<I, E> where I: Write

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> ByteIo<I, E> where I: ReadAt

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> ByteIo<I, E> where I: WriteAt

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.

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