[−][src]Trait deku::BitsWriter

pub trait BitsWriter {
    fn write(
        &self, 
        output_is_le: bool, 
        bit_size: Option<usize>
    ) -> Result<BitVec<Msb0, u8>, DekuError>;
}

"Writer" trait: write from type to bits

Required methods

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`

Write type to bits

output_is_le - true if output is to be interpreted as little endian, false otherwise (controlled via endian deku attribute)
bit_size - Some if bits or bytes deku attributes provided, None otherwise

Loading content...

Implementations on Foreign Types

`impl BitsWriter for [u8; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u32; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u64; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u128; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [usize; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i8; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i16; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i32; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i64; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [i128; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [isize; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f32; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [f64; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl<T: BitsWriter> BitsWriter for Vec<T>`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for u8`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for u16`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for u32`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for u64`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for u128`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for usize`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for i8`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for i16`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for i32`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for i64`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for i128`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for isize`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for f32`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for f64`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for Ipv4Addr`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for Ipv6Addr`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for IpAddr`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

Loading content...

Implementors

Loading content...

[−][src]Trait deku::BitsWriter

Required methods

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>

Implementations on Foreign Types

impl BitsWriter for [u8; 1][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 2][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 3][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 4][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 5][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 6][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 7][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 8][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 9][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 10][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 11][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 12][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 13][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 14][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 15][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 16][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 17][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 18][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 19][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 20][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 21][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 22][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 23][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 24][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 25][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 26][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 27][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 28][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 29][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 30][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 31][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u8; 32][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 1][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 2][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 3][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 4][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 5][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

impl BitsWriter for [u16; 6][src]

fn write( &self, output_is_le: bool, bit_size: Option<usize>) -> Result<BitVec<Msb0, u8>, DekuError>[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`

`impl BitsWriter for [u8; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 8]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 9]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 10]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 11]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 12]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 13]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 14]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 15]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 16]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 17]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 18]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 19]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 20]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 21]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 22]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 23]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 24]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 25]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 26]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 27]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 28]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 29]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 30]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 31]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u8; 32]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 1]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 2]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 3]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 4]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 5]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 6]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 7]`[src]

`fn write( &self, output_is_le: bool, bit_size: Option<usize> ) -> Result<BitVec<Msb0, u8>, DekuError>`[src]

`impl BitsWriter for [u16; 8]`[src]