Struct byteordered::ByteOrdered

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

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.

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

pub fn be(inner: T) -> Self

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

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. That is, the type representing the byte order is the enum type Endianness.

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 compile time, the other constructors are preferred (e.g. new, le or be), so as to avoid the overhead of dynamic dispatching.

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: The other constructors (le, be, native, and runtime) are more recommended because they are easier to use and leave a better signal of whether the endianness is known at compile time or at run time. For example, if you pass a value literal of type Endianness (such as Endianness::Little), the program will perform dynamic dispatching in spite of the fixed byte order. The use of this method is more appropriate when constructing functions which are generic over the endianness type.

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 inner_mut(&mut self) -> &mut T

Obtains an exclusive mutable reference to the inner reader or writer in this wrapper. Information about the assumed byte order is ignored until the reference is dropped.

pub fn as_mut(&mut self) -> ByteOrdered<&mut T, E> where
    E: Copy, 

Converts from ByteOrdered<T, E> to ByteOrdered<&mut T, E>, copying the endianness information.

pub fn into_parts(self) -> (T, E)

Disbands a ByteOrder into its parts.

pub fn map<F, U>(self, f: F) -> ByteOrdered<U, E> where
    F: FnOnce(T) -> U, 

Maps a ByteOrdered<T, E> into a ByteOrdered<O, E> by applying the given function to the inner reader or writer.

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

Changes the assumed byte order of the reader or writer.

pub fn set_endianness(&mut self, endianness: E)

Modifies the assumed byte order of the reader or writer inline with the value. Since the endianness type needs to be the same, this function is only relevant when E is a run-time defined byte order (see Endianness).

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_native(self) -> ByteOrdered<T, StaticEndianness<NativeEndian>>

Changes the assumed byte order of the reader or writer to the system’s native endianness.

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 endianness(&self) -> E where
    E: Copy, 

Retrieves the byte order assumed by this wrapper.

pub fn is_native(&self) -> bool where
    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 byteordered::ByteOrdered;

let mut rdr = ByteOrdered::native(&[2, 5][..]);
assert_eq!(2, rdr.read_i8()?);
assert_eq!(5, rdr.read_i8()?);

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 byteordered::ByteOrdered;

let mut rdr = ByteOrdered::native(&[2, 5][..]);
assert_eq!(2, rdr.read_u8()?);
assert_eq!(5, rdr.read_u8()?);

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 byteordered::ByteOrdered;

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

pub fn read_i16_into(&mut self, dst: &mut [i16]) -> IoResult<()>

Reads a sequence of signed 16 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

Errors

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

Examples

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

let mut out = [0; 2];
let mut rdr = ByteOrdered::be(&[0x00, 0xc1, 0xff, 0x7c][..]);
rdr.read_i16_into(&mut out)?;
assert_eq!(out, [193, -132]);

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_u16_into(&mut self, dst: &mut [u16]) -> IoResult<()>

Reads a sequence of unsigned 16 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_i32_into(&mut self, dst: &mut [i32]) -> IoResult<()>

Reads a sequence of signed 32 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_u32_into(&mut self, dst: &mut [u32]) -> IoResult<()>

Reads a sequence of unsigned 32 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_i64_into(&mut self, dst: &mut [i64]) -> IoResult<()>

Reads a sequence of signed 64 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_u64_into(&mut self, dst: &mut [u64]) -> IoResult<()>

Reads a sequence of unsigned 64 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

Errors

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

pub fn read_i128(&mut self) -> IoResult<i128>

Reads a signed 128 bit integer from the underlying reader.

Errors

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

pub fn read_i128_into(&mut self, dst: &mut [i128]) -> IoResult<()>

Reads a sequence of signed 128 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

Errors

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

pub fn read_u128(&mut self) -> IoResult<u128>

Reads an unsigned 16 bit integer from the underlying reader.

Errors

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

pub fn read_u128_into(&mut self, dst: &mut [u128]) -> IoResult<()>

Reads a sequence of unsigned 128 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_f32_into(&mut self, dst: &mut [f32]) -> IoResult<()>

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

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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.

pub fn read_f64_into(&mut self, dst: &mut [f64]) -> IoResult<()>

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

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of dst are unspecified.

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_i128(&mut self, x: i128) -> IoResult<()>

Writes a signed 128 bit integer to the underlying writer.

Errors

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

pub fn write_u128(&mut self, x: u128) -> IoResult<()>

Writes an unsigned 128 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.

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

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

recently added

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

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

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

fn lines(self) -> Lines<Self>

Returns an iterator over the lines of this reader.

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

fn clone(&self) -> ByteOrdered<T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

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<T, E> From<(T, E)> for ByteOrdered<T, E>

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

Performs the conversion.

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.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adapter which will chain this stream with another.

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

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 Self

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