Struct positioned_io::ByteIo

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

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 byteorder::BigEndian;
use positioned_io::ByteIo;

let mut buf = [0; 8];

{
    let mut io : ByteIo<_, BigEndian> = ByteIo::new(&mut buf[..]);
    // All writes will automatically be BigEndian.
    io.write_u16(300)?;
    io.write_u32(1_000_000)?;
    io.write_i16(-1)?;
}

assert_eq!(buf, [1, 44, 0, 15, 66, 64, 255, 255]);

Implementations

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

pub 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 byteorder::BigEndian;
use positioned_io::ByteIo;

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

pub fn into_inner(self) -> I

Returns the underlying reader or writer.

pub fn get_ref(&self) -> &I

Borrows the underlying reader or writer.

pub fn get_mut(&mut self) -> &mut I

Mutably borrows the underlying reader or writer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations

impl<I: Clone, E: Clone + ByteOrder> Clone for ByteIo<I, E>

fn clone(&self) -> ByteIo<I, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug, E: Debug + ByteOrder> Debug for ByteIo<I, E>

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

Formats the value using the given formatter.

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

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_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

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

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_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, appending them to buf.

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

Read the exact number of bytes required to fill buf.

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)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

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

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

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

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

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

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

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

Attempts to write an entire buffer into this writer.

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.

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 Selfwhere Self: Sized,

Creates a “by reference” adapter for this instance of Write.

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

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

Writes bytes from a buffer to an offset, returning the number of bytes written.

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

Flush this writer, ensuring that any intermediately buffered data reaches its destination.

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

Writes a complete buffer at an offset.