Enum LittleEndian

pub enum LittleEndian

Defines little-endian serialization.

Note that this type has no value constructor. It is used purely at the type level.

Examples

Write and read u32 numbers in little endian order:

use byteorder_lite::{ByteOrder, LittleEndian};

let mut buf = [0; 4];
LittleEndian::write_u32(&mut buf, 1_000_000);
assert_eq!(1_000_000, LittleEndian::read_u32(&buf));

Trait Implementations

impl ByteOrder for LittleEndian

fn read_u16(buf: &[u8]) -> u16
fn read_u32(buf: &[u8]) -> u32
fn read_u64(buf: &[u8]) -> u64
fn read_u128(buf: &[u8]) -> u128
fn read_uint(buf: &[u8], nbytes: usize) -> u64
fn read_uint128(buf: &[u8], nbytes: usize) -> u128
fn write_u16(buf: &mut [u8], n: u16)
fn write_u32(buf: &mut [u8], n: u32)
fn write_u64(buf: &mut [u8], n: u64)
fn write_u128(buf: &mut [u8], n: u128)
fn write_uint(buf: &mut [u8], n: u64, nbytes: usize)
fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize)
fn read_u16_into(src: &[u8], dst: &mut [u16])
fn read_u32_into(src: &[u8], dst: &mut [u32])
fn read_u64_into(src: &[u8], dst: &mut [u64])
fn read_u128_into(src: &[u8], dst: &mut [u128])
fn read_i16_into(src: &[u8], dst: &mut [i16])
fn read_i32_into(src: &[u8], dst: &mut [i32])
fn read_i64_into(src: &[u8], dst: &mut [i64])
fn read_i128_into(src: &[u8], dst: &mut [i128])
fn read_f32_into(src: &[u8], dst: &mut [f32])
fn read_f64_into(src: &[u8], dst: &mut [f64])
fn write_u16_into(src: &[u16], dst: &mut [u8])
fn write_u32_into(src: &[u32], dst: &mut [u8])
fn write_u64_into(src: &[u64], dst: &mut [u8])
fn write_u128_into(src: &[u128], dst: &mut [u8])
fn write_i16_into(src: &[i16], dst: &mut [u8])
fn write_i32_into(src: &[i32], dst: &mut [u8])
fn write_i64_into(src: &[i64], dst: &mut [u8])
fn write_i128_into(src: &[i128], dst: &mut [u8])
fn write_f32_into(src: &[f32], dst: &mut [u8])
fn write_f64_into(src: &[f64], dst: &mut [u8])
fn from_slice_u16(numbers: &mut [u16])
fn from_slice_u32(numbers: &mut [u32])
fn from_slice_u64(numbers: &mut [u64])
fn from_slice_u128(numbers: &mut [u128])
fn from_slice_i16(numbers: &mut [i16])
fn from_slice_i32(numbers: &mut [i32])
fn from_slice_i64(numbers: &mut [i64])
fn from_slice_i128(numbers: &mut [i128])
fn from_slice_f32(numbers: &mut [f32])
fn from_slice_f64(numbers: &mut [f64])

impl Clone for LittleEndian

fn clone(&self) -> LittleEndian

impl Copy for LittleEndian

impl Debug for LittleEndian

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

impl Default for LittleEndian

fn default() -> LittleEndian

impl Eq for LittleEndian

impl Hash for LittleEndian

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

impl Ord for LittleEndian

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

impl PartialEq for LittleEndian

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

impl PartialOrd for LittleEndian

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

impl StructuralPartialEq for LittleEndian

Auto Trait Implementations

impl Freeze for LittleEndian

impl RefUnwindSafe for LittleEndian

impl Send for LittleEndian

impl Sync for LittleEndian

impl Unpin for LittleEndian

impl UnsafeUnpin for LittleEndian

impl UnwindSafe for LittleEndian

Blanket Implementations

impl<T> Any for LittleEndian where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for LittleEndian where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for LittleEndian where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for LittleEndian where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for LittleEndian

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for LittleEndian where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for LittleEndian where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for LittleEndian where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for LittleEndian where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>