Trait deku::DekuWrite[−][src]

pub trait DekuWrite<Ctx = ()> {
    fn write(
        &self, 
        output: &mut BitVec<Msb0, u8>, 
        ctx: Ctx
    ) -> Result<(), DekuError>;
}

“Writer” trait: write from type to bits

Required methods

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

Write type to bits

output - Sink to store resulting bits
ctx - A context required by context-sensitive reading. A unit type () means no context needed.

Loading content...

Implementations on Foreign Types

`impl<Ctx> DekuWrite<Ctx> for bool where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

wrapper around u8::write with consideration to context, such as bit size

`impl DekuWrite<()> for NonZeroU8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU128`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroUsize`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI128`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroIsize`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroIsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroIsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroIsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl<T: DekuWrite<Ctx>, Ctx: Copy> DekuWrite<Ctx> for Option<T>`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

Write T if Some

inner_ctx - The context required by T.

Examples

let data = Some(1u8);
let mut output = bitvec![Msb0, u8;];
data.write(&mut output, Endian::Big).unwrap();
assert_eq!(output, bitvec![Msb0, u8; 0, 0, 0, 0, 0, 0, 0, 1])

`impl DekuWrite<(Endian, Size)> for u8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for u8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for u8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for u8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for u16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for u16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for u16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for u16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for u32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for u32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for u32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for u32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for u64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for u64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for u64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for u64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for u128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for u128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for u128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for u128`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for usize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for usize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for usize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for usize`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for i8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for i8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for i8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for i8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for i16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for i16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for i16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for i16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for i32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for i32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for i32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for i32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for i64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for i64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for i64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for i64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for i128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for i128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for i128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for i128`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for isize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for isize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for isize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for isize`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for f32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for f32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for f32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for f32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for f64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for f64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for f64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, bit_size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for f64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, _: ()) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[i8] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 1] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 2] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 3] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 4] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 5] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 6] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 7] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 8] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 9] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 10] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 11] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 12] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 13] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 14] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 15] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 16] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 17] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 18] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 19] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 20] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 21] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 22] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 23] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 24] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 25] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 26] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 27] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 28] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 29] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 30] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 31] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i8; 32] where i8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[i16] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 1] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 2] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 3] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 4] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 5] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 6] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 7] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 8] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 9] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 10] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 11] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 12] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 13] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 14] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 15] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 16] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 17] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 18] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 19] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 20] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 21] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 22] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 23] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 24] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 25] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 26] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 27] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 28] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 29] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 30] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 31] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i16; 32] where i16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[i32] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 1] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 2] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 3] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 4] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 5] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 6] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 7] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 8] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 9] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 10] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 11] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 12] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 13] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 14] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 15] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 16] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 17] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 18] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 19] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 20] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 21] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 22] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 23] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 24] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 25] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 26] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 27] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 28] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 29] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 30] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 31] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i32; 32] where i32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[i64] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 1] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 2] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 3] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 4] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 5] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 6] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 7] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 8] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 9] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 10] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 11] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 12] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 13] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 14] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 15] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 16] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 17] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 18] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 19] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 20] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 21] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 22] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 23] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 24] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 25] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 26] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 27] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 28] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 29] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 30] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 31] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i64; 32] where i64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[i128] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 1] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 2] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 3] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 4] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 5] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 6] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 7] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 8] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 9] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 10] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 11] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 12] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 13] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 14] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 15] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 16] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 17] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 18] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 19] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 20] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 21] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 22] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 23] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 24] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 25] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 26] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 27] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 28] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 29] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 30] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 31] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [i128; 32] where i128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[isize] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 1] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 2] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 3] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 4] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 5] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 6] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 7] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 8] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 9] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 10] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 11] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 12] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 13] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 14] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 15] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 16] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 17] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 18] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 19] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 20] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 21] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 22] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 23] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 24] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 25] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 26] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 27] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 28] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 29] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 30] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 31] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [isize; 32] where isize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[u8] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 1] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 2] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 3] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 4] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 5] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 6] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 7] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 8] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 9] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 10] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 11] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 12] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 13] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 14] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 15] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 16] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 17] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 18] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 19] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 20] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 21] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 22] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 23] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 24] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 25] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 26] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 27] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 28] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 29] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 30] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 31] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u8; 32] where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[u16] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 1] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 2] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 3] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 4] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 5] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 6] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 7] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 8] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 9] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 10] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 11] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 12] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 13] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 14] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 15] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 16] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 17] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 18] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 19] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 20] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 21] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 22] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 23] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 24] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 25] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 26] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 27] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 28] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 29] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 30] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 31] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u16; 32] where u16: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[u32] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 1] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 2] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 3] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 4] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 5] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 6] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 7] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 8] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 9] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 10] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 11] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 12] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 13] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 14] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 15] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 16] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 17] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 18] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 19] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 20] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 21] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 22] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 23] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 24] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 25] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 26] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 27] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 28] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 29] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 30] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 31] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u32; 32] where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[u64] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 1] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 2] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 3] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 4] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 5] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 6] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 7] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 8] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 9] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 10] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 11] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 12] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 13] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 14] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 15] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 16] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 17] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 18] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 19] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 20] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 21] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 22] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 23] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 24] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 25] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 26] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 27] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 28] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 29] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 30] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 31] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u64; 32] where u64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[u128] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 1] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 2] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 3] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 4] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 5] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 6] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 7] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 8] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 9] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 10] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 11] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 12] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 13] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 14] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 15] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 16] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 17] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 18] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 19] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 20] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 21] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 22] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 23] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 24] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 25] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 26] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 27] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 28] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 29] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 30] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 31] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [u128; 32] where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[usize] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 1] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 2] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 3] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 4] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 5] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 6] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 7] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 8] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 9] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 10] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 11] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 12] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 13] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 14] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 15] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 16] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 17] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 18] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 19] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 20] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 21] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 22] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 23] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 24] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 25] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 26] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 27] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 28] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 29] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 30] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 31] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [usize; 32] where usize: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[f32] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 1] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 2] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 3] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 4] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 5] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 6] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 7] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 8] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 9] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 10] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 11] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 12] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 13] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 14] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 15] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 16] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 17] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 18] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 19] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 20] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 21] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 22] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 23] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 24] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 25] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 26] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 27] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 28] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 29] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 30] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 31] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f32; 32] where f32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for &[f64] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 1] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 2] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 3] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 4] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 5] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 6] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 7] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 8] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 9] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 10] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 11] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 12] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 13] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 14] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 15] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 16] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 17] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 18] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 19] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 20] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 21] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 22] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 23] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 24] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 25] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 26] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 27] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 28] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 29] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 30] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 31] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for [f64; 32] where f64: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx: Copy> DekuWrite<Ctx> for ()`[src]

`fn write( &self, _output: &mut BitVec<Msb0, u8>, _inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

NOP on write

`impl<T: DekuWrite<Ctx>, Ctx: Copy> DekuWrite<Ctx> for Vec<T>`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

Write all Ts in a Vec to bits.

inner_ctx - The context required by T.

Examples

let data = vec![1u8];
let mut output = bitvec![Msb0, u8;];
data.write(&mut output, Endian::Big).unwrap();
assert_eq!(output, bitvec![Msb0, u8; 0, 0, 0, 0, 0, 0, 0, 1])

`impl<Ctx: Copy> DekuWrite<Ctx> for CString where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx> DekuWrite<Ctx> for Ipv4Addr where u32: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx> DekuWrite<Ctx> for Ipv6Addr where u128: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx> DekuWrite<Ctx> for IpAddr where Ipv6Addr: DekuWrite<Ctx>, Ipv4Addr: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<T, Ctx> DekuWrite<Ctx> for Box<T> where T: DekuWrite<Ctx>, Ctx: Copy,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

Write T from box

`impl<T, Ctx> DekuWrite<Ctx> for Box<[T]> where T: DekuWrite<Ctx>, Ctx: Copy,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

Write all Ts to bits

Loading content...

Implementors

Loading content...

Trait deku::DekuWrite[−][src]

Required methods

fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx) -> Result<(), DekuError>[src]

Implementations on Foreign Types

impl<Ctx> DekuWrite<Ctx> for bool where u8: DekuWrite<Ctx>, [src]

fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroU8[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroU8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroU8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroU8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroU16[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroU16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroU16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroU16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroU32[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroU32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroU32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroU32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroU64[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroU64[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroU64[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroU64[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroU128[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroU128[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroU128[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroU128[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroUsize[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroUsize[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroUsize[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroUsize[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroI8[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroI8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroI8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroI8[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroI16[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroI16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroI16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroI16[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroI32[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

impl DekuWrite<(Endian, Size)> for NonZeroI32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size)) -> Result<(), DekuError>[src]

impl DekuWrite<Endian> for NonZeroI32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian) -> Result<(), DekuError>[src]

impl DekuWrite<Size> for NonZeroI32[src]

fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size) -> Result<(), DekuError>[src]

impl DekuWrite<()> for NonZeroI64[src]

fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl<Ctx> DekuWrite<Ctx> for bool where u8: DekuWrite<Ctx>,` [src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, inner_ctx: Ctx ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroU128`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroU128`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroUsize`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroUsize`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI8`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI8`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI16`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI16`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI32`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, endian: Endian ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Size> for NonZeroI32`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, size: Size ) -> Result<(), DekuError>`[src]

`impl DekuWrite<()> for NonZeroI64`[src]

`fn write(&self, output: &mut BitVec<Msb0, u8>, (): ()) -> Result<(), DekuError>`[src]

`impl DekuWrite<(Endian, Size)> for NonZeroI64`[src]

`fn write( &self, output: &mut BitVec<Msb0, u8>, (endian, size): (Endian, Size) ) -> Result<(), DekuError>`[src]

`impl DekuWrite<Endian> for NonZeroI64`[src]