Enum Endianness

pub enum Endianness {
    Little,
    Big,
}

Enumerate for materializing the two kinds of machine byte order supported by Rust in a dynamic fashion. That is, the information of whether to read or write data in Little Endian or in Big Endian is resolved at run time by observing this value.

Using this type as the generic endianness type E in a ByteOrdered is useful when this information can only be retrieved from a source that is unknown to the compiler.

Variants

Little

Little Endian

Big

Big Endian

Implementations

impl Endianness

pub fn native() -> Endianness

Obtains this system’s native endianness.

On this platform, the function returns Endianness::Little.

pub fn le_iff(e: bool) -> Endianness

Obtains Little Endian if and only if the given value is true.

Examples

let data: &[u8] = &[4, 1];
let e = Endianness::le_iff(2 + 2 == 4);
assert_eq!(e.read_u16(data).unwrap(), 260);

let e = Endianness::le_iff(2 + 2 >= 5);
assert_eq!(e.read_u16(data).unwrap(), 1025);

pub fn be_iff(e: bool) -> Endianness

Obtains Big Endian if and only if the given value is true.

Examples

assert_eq!(Endianness::be_iff(2 + 2 == 4), Endianness::Big);
assert_eq!(Endianness::be_iff(2 + 2 >= 5), Endianness::Little);

pub fn to_opposite(self) -> Endianness

Obtains the opposite endianness: Little Endian returns Big Endian and vice versa.

Trait Implementations

impl Clone for Endianness

fn clone(&self) -> Endianness

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Endianness

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

Formats the value using the given formatter.

impl Endian for Endianness

type Opposite = Endianness

A type which can represent a byte order that is opposite to this one.

fn into_opposite(self) -> <Endianness as Endian>::Opposite

Converts the receiver into its opposite.

fn is_native(self) -> bool

Checks whether this value represents the system’s native endianness.

fn read_i16<S>(self, src: S) -> Result<i16, Error>

where S: Read,

Reads a signed 16 bit integer from the given reader.

fn read_u16<S>(self, src: S) -> Result<u16, Error>

where S: Read,

Reads an unsigned 16 bit integer from the given reader.

fn read_i32<S>(self, src: S) -> Result<i32, Error>

where S: Read,

Reads a signed 32 bit integer from the given reader.

fn read_u32<S>(self, src: S) -> Result<u32, Error>

where S: Read,

Reads an unsigned 32 bit integer from the given reader.

fn read_i64<S>(self, src: S) -> Result<i64, Error>

where S: Read,

Reads a signed 64 bit integer from the given reader.

fn read_u64<S>(self, src: S) -> Result<u64, Error>

where S: Read,

Reads an unsigned 64 bit integer from the given reader.

fn read_f32<S>(self, src: S) -> Result<f32, Error>

where S: Read,

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

fn read_f64<S>(self, src: S) -> Result<f64, Error>

where S: Read,

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

fn read_i128<S>(self, src: S) -> Result<i128, Error>

where S: Read,

Reads a signed 128 bit integer from the given reader.

fn read_u128<S>(self, src: S) -> Result<u128, Error>

where S: Read,

Reads an unsigned 128 bit integer from the given reader.

fn read_i16_into<S>(self, src: S, dst: &mut [i16]) -> Result<(), Error>

where S: Read,

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

fn read_u16_into<S>(self, src: S, dst: &mut [u16]) -> Result<(), Error>

where S: Read,

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

fn read_i32_into<S>(self, src: S, dst: &mut [i32]) -> Result<(), Error>

where S: Read,

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

fn read_u32_into<S>(self, src: S, dst: &mut [u32]) -> Result<(), Error>

where S: Read,

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

fn read_i64_into<S>(self, src: S, dst: &mut [i64]) -> Result<(), Error>

where S: Read,

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

fn read_u64_into<S>(self, src: S, dst: &mut [u64]) -> Result<(), Error>

where S: Read,

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

fn read_f32_into<S>(self, src: S, dst: &mut [f32]) -> Result<(), Error>

where S: Read,

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

fn read_f64_into<S>(self, src: S, dst: &mut [f64]) -> Result<(), Error>

where S: Read,

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

fn read_i128_into<S>(self, src: S, dst: &mut [i128]) -> Result<(), Error>

where S: Read,

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

fn read_u128_into<S>(self, src: S, dst: &mut [u128]) -> Result<(), Error>

where S: Read,

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

fn write_i16<S>(self, src: S, v: i16) -> Result<(), Error>

where S: Write,

Writes a signed 16 bit integer to the given writer.

fn write_u16<S>(self, src: S, v: u16) -> Result<(), Error>

where S: Write,

Writes an unsigned 16 bit integer to the given writer.

fn write_i32<S>(self, src: S, v: i32) -> Result<(), Error>

where S: Write,

Writes a signed 32 bit integer to the given writer.

fn write_u32<S>(self, src: S, v: u32) -> Result<(), Error>

where S: Write,

Writes an unsigned 32 bit integer to the given writer.

fn write_i64<S>(self, src: S, v: i64) -> Result<(), Error>

where S: Write,

Writes a signed 64 bit integer to the given writer.

fn write_u64<S>(self, src: S, v: u64) -> Result<(), Error>

where S: Write,

Writes an unsigned 64 bit integer to the given writer.

fn write_f32<S>(self, src: S, v: f32) -> Result<(), Error>

where S: Write,

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

fn write_f64<S>(self, src: S, v: f64) -> Result<(), Error>

where S: Write,

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

fn write_i128<S>(self, src: S, v: i128) -> Result<(), Error>

where S: Write,

Writes a signed 128 bit integer to the given writer.

fn write_u128<S>(self, src: S, v: u128) -> Result<(), Error>

where S: Write,

Writes an unsigned 128 bit integer to the given writer.

impl From<Endianness> for BasicDecoder

fn from(endianness: Endianness) -> Self

Converts to this type from the input type.

impl From<StaticEndianness<BigEndian>> for Endianness

fn from(_: StaticEndianness<BigEndian>) -> Endianness

Converts to this type from the input type.

impl From<StaticEndianness<LittleEndian>> for Endianness

fn from(_: StaticEndianness<LittleEndian>) -> Endianness

Converts to this type from the input type.

impl Hash for Endianness

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Endianness

fn cmp(&self, other: &Endianness) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<StaticEndianness<BigEndian>> for Endianness

fn eq(&self, _: &StaticEndianness<BigEndian>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StaticEndianness<LittleEndian>> for Endianness

fn eq(&self, _: &StaticEndianness<LittleEndian>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Endianness

fn eq(&self, other: &Endianness) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Endianness

fn partial_cmp(&self, other: &Endianness) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Endianness

impl Eq for Endianness

impl StructuralPartialEq for Endianness