Trait tlbits::BitPackAs

pub trait BitPackAs<T: ?Sized> {
    // Required method
    fn pack_as<W>(source: &T, writer: W) -> Result<(), W::Error>
       where W: BitWriter;
}

Required Methods

fn pack_as<W>(source: &T, writer: W) -> Result<(), W::Error>

where W: BitWriter,

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, T, As> BitPackAs<&'a T> for &'a As

where As: BitPackAs<T> + ?Sized, T: ?Sized,

fn pack_as<W>(source: &&T, writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<'a, T, As> BitPackAs<&'a mut T> for &'a mut As

where As: BitPackAs<T> + ?Sized, T: ?Sized,

fn pack_as<W>(source: &&mut T, writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0> BitPackAs<(T0,)> for (As0,)

where As0: BitPackAs<T0>,

fn pack_as<W>(source: &(T0,), writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1> BitPackAs<(T0, T1)> for (As0, As1)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>,

fn pack_as<W>(source: &(T0, T1), writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2> BitPackAs<(T0, T1, T2)> for (As0, As1, As2)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>,

fn pack_as<W>(source: &(T0, T1, T2), writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3> BitPackAs<(T0, T1, T2, T3)> for (As0, As1, As2, As3)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>,

fn pack_as<W>(source: &(T0, T1, T2, T3), writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4> BitPackAs<(T0, T1, T2, T3, T4)> for (As0, As1, As2, As3, As4)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>,

fn pack_as<W>(source: &(T0, T1, T2, T3, T4), writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5> BitPackAs<(T0, T1, T2, T3, T4, T5)> for (As0, As1, As2, As3, As4, As5)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>, As5: BitPackAs<T5>,

fn pack_as<W>( source: &(T0, T1, T2, T3, T4, T5), writer: W ) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6> BitPackAs<(T0, T1, T2, T3, T4, T5, T6)> for (As0, As1, As2, As3, As4, As5, As6)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>, As5: BitPackAs<T5>, As6: BitPackAs<T6>,

fn pack_as<W>( source: &(T0, T1, T2, T3, T4, T5, T6), writer: W ) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7> BitPackAs<(T0, T1, T2, T3, T4, T5, T6, T7)> for (As0, As1, As2, As3, As4, As5, As6, As7)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>, As5: BitPackAs<T5>, As6: BitPackAs<T6>, As7: BitPackAs<T7>,

fn pack_as<W>( source: &(T0, T1, T2, T3, T4, T5, T6, T7), writer: W ) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8> BitPackAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>, As5: BitPackAs<T5>, As6: BitPackAs<T6>, As7: BitPackAs<T7>, As8: BitPackAs<T8>,

fn pack_as<W>( source: &(T0, T1, T2, T3, T4, T5, T6, T7, T8), writer: W ) -> Result<(), W::Error>

where W: BitWriter,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9> BitPackAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9)

where As0: BitPackAs<T0>, As1: BitPackAs<T1>, As2: BitPackAs<T2>, As3: BitPackAs<T3>, As4: BitPackAs<T4>, As5: BitPackAs<T5>, As6: BitPackAs<T6>, As7: BitPackAs<T7>, As8: BitPackAs<T8>, As9: BitPackAs<T9>,

fn pack_as<W>( source: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), writer: W ) -> Result<(), W::Error>

where W: BitWriter,

impl<T, As> BitPackAs<Option<T>> for Option<As>

where As: BitPackAs<T>,

fn pack_as<W>(source: &Option<T>, writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T, As> BitPackAs<[T]> for [As]

where As: BitPackAs<T>,

fn pack_as<W>(source: &[T], writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T, As> BitPackAs<Box<T>> for Box<As>

where As: BitPackAs<T> + ?Sized,

fn pack_as<W>(source: &Box<T>, writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T, As> BitPackAs<Rc<T>> for Rc<As>

where As: BitPackAs<T> + ?Sized,

fn pack_as<W>(source: &Rc<T>, writer: W) -> Result<(), W::Error>

where W: BitWriter,

impl<T, As> BitPackAs<Arc<T>> for Arc<As>

where As: BitPackAs<T> + ?Sized,

fn pack_as<W>(source: &Arc<T>, writer: W) -> Result<(), W::Error>

where W: BitWriter,

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

where As: BitPackAs<T>,

fn pack_as<W>(source: &[T; N], writer: W) -> Result<(), W::Error>

where W: BitWriter,

Implementors

impl<Left, Right, AsLeft, AsRight> BitPackAs<Either<Left, Right>> for Either<AsLeft, AsRight>

where AsLeft: BitPackAs<Left>, AsRight: BitPackAs<Right>,

impl<T> BitPackAs<Option<T>> for Either<(), T>

where T: BitPack,

impl<T> BitPackAs<T> for AsBitSlice

where T: AsRef<BitSlice<u8, Msb0>>,

impl<T> BitPackAs<T> for AsBytes

where T: AsRef<[u8]>,

impl<T> BitPackAs<T> for Same

where T: BitPack,

impl<T, As> BitPackAs<T> for FromInto<As>

where T: Into<As> + Clone, As: BitPack,

impl<T, As> BitPackAs<T> for FromIntoRef<As>

where for<'a> &'a T: Into<As>, As: BitPack,

impl<T, As> BitPackAs<T> for TryFromInto<As>

where T: TryInto<As> + Clone, <T as TryInto<As>>::Error: Display, As: BitPack,

impl<const BITS: usize> BitPackAs<i8> for NBits<BITS>

impl<const BITS: usize> BitPackAs<i16> for NBits<BITS>

impl<const BITS: usize> BitPackAs<i32> for NBits<BITS>

impl<const BITS: usize> BitPackAs<i64> for NBits<BITS>

impl<const BITS: usize> BitPackAs<i128> for NBits<BITS>

impl<const BITS: usize> BitPackAs<isize> for NBits<BITS>

impl<const BITS: usize> BitPackAs<u8> for NBits<BITS>

impl<const BITS: usize> BitPackAs<u16> for NBits<BITS>

impl<const BITS: usize> BitPackAs<u32> for NBits<BITS>

impl<const BITS: usize> BitPackAs<u64> for NBits<BITS>

impl<const BITS: usize> BitPackAs<u128> for NBits<BITS>

impl<const BITS: usize> BitPackAs<usize> for NBits<BITS>

impl<const BITS: usize> BitPackAs<BigInt> for NBits<BITS>

impl<const BITS: usize> BitPackAs<BigUint> for NBits<BITS>

impl<const BITS_FOR_BYTES_LEN: usize> BitPackAs<BigInt> for VarInt<BITS_FOR_BYTES_LEN>

impl<const BITS_FOR_BYTES_LEN: usize> BitPackAs<BigUint> for VarUint<BITS_FOR_BYTES_LEN>

impl<const BITS_FOR_BYTES_LEN: usize, T> BitPackAs<T> for VarBytes<BITS_FOR_BYTES_LEN>

where T: AsRef<[u8]> + ?Sized,