Struct byteordered::ByteOrdered

pub struct ByteOrdered<T, E> { /* private fields */ }

Wrapper type for a reader or writer with an assumed byte order.

More details can be found at the crate level documentation.

Implementations

impl<T> ByteOrdered<T, StaticEndianness<LittleEndian>>

pub fn le(inner: T) -> Self

Obtains a new reader or writer that assumes data in little endian.

pub fn endianness(&self) -> Endianness

Retrieves the runtime byte order assumed by this wrapper.

impl<T> ByteOrdered<T, StaticEndianness<BigEndian>>

pub fn be(inner: T) -> Self

Obtains a new reader or writer that assumes data in big endian.

pub fn endianness(&self) -> Endianness

Retrieves the runtime byte order assumed by this wrapper.

impl<T> ByteOrdered<T, StaticEndianness<NativeEndian>>

pub fn native(inner: T) -> Self

Obtains a new reader or writer that assumes data in the system’s native endianness. While this method might sounds a bit pointless, it enables easier byte order changes through method chaining).

impl<T> ByteOrdered<T, StaticEndianness<NetworkEndian>>

pub fn network(inner: T) -> Self

Obtains a new reader or writer that assumes network order.

impl<T> ByteOrdered<T, Endianness>

pub fn runtime(inner: T, endianness: Endianness) -> Self

Creates a new reader or writer that assumes data in the given byte order known at run-time.

Although it is equivalent to ByteOrdered::new, this function leaves a code signal that subsequent calls depend on conditions resolved at run-time. If you know the data’s endianness in advance, the other constructors are preferred (e.g. new, le or be), so as to avoid the overhead of dynamic dispatching.

pub fn endianness(&self) -> Endianness

Retrieves the runtime byte order assumed by this wrapper.

impl<T, E> ByteOrdered<T, E>where
    E: Endian,

pub fn new(inner: T, endianness: E) -> Self

Creates a new reader or writer that assumes data in the given byte order. This flexible constructor admits any kind of byte order (static and dynamic). Note that the other constructors are easier to use (e.g. le, be, [native'], or [runtime`]).

pub fn into_inner(self) -> T

Recovers the inner reader or writer from this wrapper. Information about the assumed byte order is discarded.

pub fn into_endianness<E2: Endian>(self, endianness: E2) -> ByteOrdered<T, E2>

Changes the assumed byte order of the reader or writer.

pub fn into_le(self) -> ByteOrdered<T, StaticEndianness<LittleEndian>>

Changes the assumed byte order of the reader or writer to little endian.

pub fn into_be(self) -> ByteOrdered<T, StaticEndianness<BigEndian>>

Changes the assumed byte order of the reader or writer to little endian.

pub fn into_opposite(self) -> ByteOrdered<T, E::Opposite> where
    E: Endian,

Converts the assumed endianness to the opposite of the current order.

pub fn is_native(&self) -> boolwhere
    E: Endian,

Checks whether the assumed endianness is the system’s native byte order.

impl<R, E> ByteOrdered<R, E>where
    R: ReadBytesExt,
    E: Endian,

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

Reads a signed 8 bit integer from the underlying reader.

This method does exactly the same thing as read_i8 in byteorder::ReadBytesExt. It is included so that users do not have to import the former trait.

Errors

This method returns the same errors as Read::read_exact.

Examples

Read unsigned 8 bit integers from a Read:

use std::io::Cursor;
use byteordered::ByteOrdered;

let mut rdr = ByteOrdered::native(Cursor::new(vec![2, 5]));
assert_eq!(2, rdr.read_i8().unwrap());
assert_eq!(5, rdr.read_i8().unwrap());

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

Reads an unsigned 8 bit integer from the underlying reader.

This method does exactly the same thing as read_u8 in byteorder::ReadBytesExt. It is included so that users do not have to import the former trait.

Errors

This method returns the same errors as Read::read_exact.

Examples

Read unsigned 8 bit integers from a Read:

use std::io::Cursor;
use byteordered::ByteOrdered;

let mut rdr = ByteOrdered::native(Cursor::new(vec![2, 5]));
assert_eq!(2, rdr.read_u8().unwrap());
assert_eq!(5, rdr.read_u8().unwrap());

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

Reads a signed 16 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

Read signed 16 bit big-endian integers from a Read:

use std::io::Cursor;
use byteordered::ByteOrdered;

let mut rdr = ByteOrdered::be(Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]));
assert_eq!(193, rdr.read_i16().unwrap());
assert_eq!(-132, rdr.read_i16().unwrap());

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

Reads an unsigned 16 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads a signed 32 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads an unsigned 32 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads a signed 64 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads an unsigned 16 bit integer from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads a IEEE754 single-precision (4 bytes) floating point number from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

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

Reads a IEEE754 double-precision (8 bytes) floating point number from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

impl<W, E> ByteOrdered<W, E>where
    W: WriteBytesExt,
    E: Endian,

pub fn write_i8(&mut self, x: i8) -> IoResult<()>

Writes a signed 8 bit integer to the underlying writer.

Note that since this writes a single byte, no byte order conversions are used. It is included for completeness.

Errors

This method returns the same errors as Write::write_all.

pub fn write_u8(&mut self, x: u8) -> IoResult<()>

Writes an unsigned 8 bit integer to the underlying writer.

Note that since this writes a single byte, no byte order conversions are used. It is included for completeness.

Errors

This method returns the same errors as Write::write_all.

pub fn write_i16(&mut self, x: i16) -> IoResult<()>

Writes a signed 16 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

Write signed 16 bit big-endian integers to a Write:

use byteordered::ByteOrdered;

let mut wtr = ByteOrdered::be(Vec::new());
wtr.write_i16(193).unwrap();
wtr.write_i16(-132).unwrap();
assert_eq!(wtr.into_inner(), b"\x00\xc1\xff\x7c");

pub fn write_u16(&mut self, x: u16) -> IoResult<()>

Writes an unsigned 16 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_i32(&mut self, x: i32) -> IoResult<()>

Writes a signed 32 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_u32(&mut self, x: u32) -> IoResult<()>

Writes an unsigned 32 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_i64(&mut self, x: i64) -> IoResult<()>

Writes a signed 64 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_u64(&mut self, x: u64) -> IoResult<()>

Writes an unsigned 64 bit integer to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_f32(&mut self, x: f32) -> IoResult<()>

Writes a IEEE754 single-precision (4 bytes) floating point number to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

pub fn write_f64(&mut self, x: f64) -> IoResult<()>

Writes a IEEE754 double-precision (8 bytes) floating point number to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Trait Implementations

impl<T, E> BufRead for ByteOrdered<T, E>where
    T: BufRead,

fn fill_buf(&mut self) -> IoResult<&[u8]>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> IoResult<usize>

Read all bytes into buf until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> IoResult<usize>

Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer. You do not need to clear the buffer before appending.

fn has_data_left(&mut self) -> Result<bool, Error>

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

Check if the underlying Read has any data left to be read.

fn split(self, byte: u8) -> Split<Self>where
    Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>where
    Self: Sized,

Returns an iterator over the lines of this reader.

impl<T: Debug, E: Debug> Debug for ByteOrdered<T, E>

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

Formats the value using the given formatter.

impl<R, E> Read for ByteOrdered<R, E>where
    R: Read,

fn read(&mut self, buf: &mut [u8]) -> IoResult<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>) -> IoResult<usize>

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

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

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

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

Read the exact number of bytes required to fill buf.

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_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<T, E> Seek for ByteOrdered<T, E>where
    T: Seek,

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

Seek to an offset, in bytes, in a stream.

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

Rewind to the beginning of a 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 stream_position(&mut self) -> Result<u64, Error>

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

impl<W, E> Write for ByteOrdered<W, E>where
    W: Write,

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

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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 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_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 by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

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