Struct BigEndian

struct BigEndian

Big-endian, or most significant bits first

Implementations

impl Clone for BigEndian

fn clone(self: &Self) -> BigEndian

impl Copy for BigEndian

impl Debug for BigEndian

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

impl Endianness for BigEndian

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

impl<T> Any for BigEndian

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for BigEndian

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

impl<T> BorrowMut for BigEndian

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

impl<T> CloneToUninit for BigEndian

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

impl<T> From for BigEndian

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for BigEndian

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

impl<T, U> Into for BigEndian

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 BigEndian

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

impl<T, U> TryInto for BigEndian

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