Trait tlbits::BitUnpack

pub trait BitUnpack: Sized {
    // Required method
    fn unpack<R>(reader: R) -> Result<Self, R::Error>
       where R: BitReader;
}

Required Methods

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl BitUnpack for bool

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for i8

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for i16

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for i32

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for i64

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for i128

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for isize

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for u8

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for u16

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for u32

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for u64

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for u128

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for ()

fn unpack<R>(_reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl BitUnpack for usize

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0> BitUnpack for (T0,)

where T0: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1> BitUnpack for (T0, T1)

where T0: BitUnpack, T1: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2> BitUnpack for (T0, T1, T2)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3> BitUnpack for (T0, T1, T2, T3)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4> BitUnpack for (T0, T1, T2, T3, T4)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4, T5> BitUnpack for (T0, T1, T2, T3, T4, T5)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack, T5: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4, T5, T6> BitUnpack for (T0, T1, T2, T3, T4, T5, T6)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack, T5: BitUnpack, T6: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4, T5, T6, T7> BitUnpack for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack, T5: BitUnpack, T6: BitUnpack, T7: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BitUnpack for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack, T5: BitUnpack, T6: BitUnpack, T7: BitUnpack, T8: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BitUnpack for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: BitUnpack, T1: BitUnpack, T2: BitUnpack, T3: BitUnpack, T4: BitUnpack, T5: BitUnpack, T6: BitUnpack, T7: BitUnpack, T8: BitUnpack, T9: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T> BitUnpack for Option<T>

where T: BitUnpack,

Maybe

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T> BitUnpack for Box<T>

where T: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T> BitUnpack for Rc<T>

where T: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T> BitUnpack for Arc<T>

where T: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

impl<T, const N: usize> BitUnpack for [T; N]

where T: BitUnpack,

fn unpack<R>(reader: R) -> Result<Self, R::Error>

where R: BitReader,

Implementors

impl<Left, Right> BitUnpack for Either<Left, Right>

where Left: BitUnpack, Right: BitUnpack,

impl<T, As> BitUnpack for BitUnpackAsWrap<T, As>

where As: BitUnpackAs<T> + ?Sized,

impl<const VALUE: bool> BitUnpack for ConstBit<VALUE>

impl<const VALUE: u32, const BITS: usize> BitUnpack for ConstUint<VALUE, BITS>