Struct LittleEndian

struct LittleEndian

Little-endian, or least significant bits first

Implementations

impl Clone for LittleEndian

fn clone(self: &Self) -> LittleEndian

impl Copy for LittleEndian

impl Debug for LittleEndian

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

impl Endianness for LittleEndian

fn push<N>(queue: &mut BitQueue<Self, N>, bits: u32, value: N)
where
    N: Numeric
fn push_fixed<B: u32, N>(queue: &mut BitQueue<Self, N>, value: N)
where
    N: Numeric
fn pop<N>(queue: &mut BitQueue<Self, N>, bits: u32) -> N
where
    N: Numeric
fn pop_fixed<B: u32, N>(queue: &mut BitQueue<Self, N>) -> N
where
    N: Numeric
fn drop<N>(queue: &mut BitQueue<Self, N>, bits: u32)
where
    N: Numeric
fn next_zeros<N>(queue: &BitQueue<Self, N>) -> u32
where
    N: Numeric
fn next_ones<N>(queue: &BitQueue<Self, N>) -> u32
where
    N: Numeric
fn read_signed<R, S>(r: &mut R, bits: u32) -> Result<S>
where
    R: BitRead,
    S: SignedNumeric
fn read_signed_fixed<R, B: u32, S>(r: &mut R) -> Result<S>
where
    R: BitRead,
    S: SignedNumeric
fn write_signed<W, S>(w: &mut W, bits: u32, value: S) -> Result<()>
where
    W: BitWrite,
    S: SignedNumeric
fn write_signed_fixed<W, B: u32, S>(w: &mut W, value: S) -> Result<()>
where
    W: BitWrite,
    S: SignedNumeric
fn read_primitive<R, V>(r: &mut R) -> Result<V>
where
    R: BitRead,
    V: Primitive
fn write_primitive<W, V>(w: &mut W, value: V) -> Result<()>
where
    W: BitWrite,
    V: Primitive
fn read_numeric<R, V>(r: R) -> Result<V>
where
    R: Read,
    V: Primitive
fn write_numeric<W, V>(w: W, value: V) -> Result<()>
where
    W: Write,
    V: Primitive

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

impl<T> Any for LittleEndian

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for LittleEndian

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for LittleEndian

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

impl<T> CloneToUninit for LittleEndian

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

impl<T> From for LittleEndian

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for LittleEndian

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for LittleEndian

fn into(self: 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 for LittleEndian

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for LittleEndian

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