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.

Methods

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 compile time, 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: 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.

Important traits for ByteOrdered<R, E>

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

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

Converts from a ByteOrdered<T, E> to ByteOrdered<&mut T, E>.

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

Disbands a ByteOrder into its parts.

Important traits for ByteOrdered<R, E>

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

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

Changes the assumed byte order of the reader or writer.

Important traits for ByteOrdered<R, E>

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

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

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

Important traits for ByteOrdered<R, E>

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

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

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

Important traits for ByteOrdered<R, E>

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

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.

Important traits for ByteOrdered<R, E>

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

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

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

Performs the conversion.

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

Important traits for ByteOrdered<R, E>

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

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<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.

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" adaptor 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 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<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 by_ref(&mut self) -> &mut Self

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

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 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, 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 stream_len(&mut self) -> Result<u64, Error>

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

Returns the length of this stream (in bytes).

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

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

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