Enum BigEndian

pub enum BigEndian

Defines big-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 big endian order:

use byteorder_lite::{ByteOrder, BigEndian};

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

Trait Implementations

impl ByteOrder for BigEndian

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 BigEndian

fn clone(&self) -> BigEndian

impl Copy for BigEndian

impl Debug for BigEndian

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

impl Default for BigEndian

fn default() -> BigEndian

impl Eq for BigEndian

impl Hash for BigEndian

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

impl Ord for BigEndian

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

impl PartialEq for BigEndian

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

impl PartialOrd for BigEndian

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

impl StructuralPartialEq for BigEndian

Auto Trait Implementations

impl Freeze for BigEndian

impl RefUnwindSafe for BigEndian

impl Send for BigEndian

impl Sync for BigEndian

impl Unpin for BigEndian

impl UnsafeUnpin for BigEndian

impl UnwindSafe for BigEndian

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

impl<T> From<T> for BigEndian

fn from(t: T) -> T

Returns the argument unchanged.

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

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

impl<T, U> Into<U> for BigEndian 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 BigEndian where U: Into<T>,

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

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

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