Trait deku::DekuWrite

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

“Writer” trait: write from type to bits

Required Methods

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

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.

Implementations on Foreign Types

impl DekuWrite<(Endian, BitSize)> for i128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for f64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<BitSize> for i32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroU8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for u16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroU128

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

impl DekuWrite<(Endian, ByteSize)> for isize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for u64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for u8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for i16

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

impl DekuWrite<(Endian, BitSize)> for i32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroU32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroI128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroU64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for f32

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

impl DekuWrite<Endian> for NonZeroU64

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>, G: DekuWrite<Ctx>, H: DekuWrite<Ctx>, I: DekuWrite<Ctx>, J: DekuWrite<Ctx>, K: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F, G, H, I, J, K)

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

impl DekuWrite<ByteSize> for i128

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroU8

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

impl DekuWrite<(Endian, ByteSize)> for NonZeroUsize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroU64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for isize

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

impl DekuWrite<Endian> for NonZeroI8

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

impl DekuWrite<(Endian, BitSize)> for NonZeroIsize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C)

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

impl DekuWrite<()> for NonZeroIsize

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

impl DekuWrite<BitSize> for f32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<Endian> for i16

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F)

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

impl DekuWrite<BitSize> for u8

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for f32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for NonZeroUsize

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

impl DekuWrite<(Endian, ByteSize)> for u16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for NonZeroI16

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

impl DekuWrite<Endian> for NonZeroIsize

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

impl DekuWrite<(Endian, ByteSize)> for i16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for i8

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

impl DekuWrite<Endian> for NonZeroU128

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

impl DekuWrite<Endian> for u8

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

impl DekuWrite<Endian> for u32

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

impl<T, Ctx> DekuWrite<Ctx> for Box<[T]>where T: DekuWrite<Ctx>, Ctx: Copy,

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

Write all Ts to bits

impl DekuWrite<BitSize> for i8

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroI128

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

impl DekuWrite<()> for isize

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

impl DekuWrite<BitSize> for i16

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for u64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for f64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl<Ctx: Copy> DekuWrite<Ctx> for ()

fn write( &self, _output: &mut BitVec<u8, Msb0>, _inner_ctx: Ctx ) -> Result<(), DekuError>

NOP on write

impl<T, Ctx> DekuWrite<Ctx> for Box<T>where T: DekuWrite<Ctx>, Ctx: Copy,

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

Write T from box

impl DekuWrite<BitSize> for u128

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<Endian> for i64

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

impl DekuWrite<ByteSize> for i32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<()> for f32

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D)

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

impl DekuWrite<()> for u8

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

impl<Ctx: Copy, T, const N: usize> DekuWrite<Ctx> for [T; N]where T: DekuWrite<Ctx>,

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

impl DekuWrite<Endian> for NonZeroI32

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

impl DekuWrite<Endian> for i32

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

impl<Ctx: Copy, T> DekuWrite<Ctx> for &[T]where T: DekuWrite<Ctx>,

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

impl DekuWrite<()> for NonZeroI32

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

impl<K: DekuWrite<Ctx>, V: DekuWrite<Ctx>, S, Ctx: Copy> DekuWrite<Ctx> for HashMap<K, V, S>

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

Write all K, Vs in a HashMap to bits.

• inner_ctx - The context required by K, V. Note: depending on the Hasher S, the order in which the K, V pairs are written may change between executions. Use a deterministic Hasher for your HashMap instead of the default RandomState hasher if you don’t want the order written to change.

Examples

let mut output = bitvec![u8, Msb0;];
let mut map = HashMap::<u8, u32>::default();
map.insert(100, 0x04030201);
map.write(&mut output, Endian::Big).unwrap();
let expected: Vec<u8> = vec![100, 4, 3, 2, 1];
assert_eq!(expected, output.into_vec())

impl<Ctx: Copy> DekuWrite<Ctx> for CStringwhere u8: DekuWrite<Ctx>,

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

impl DekuWrite<()> for NonZeroUsize

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

impl DekuWrite<Endian> for u16

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

impl DekuWrite<BitSize> for isize

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for f64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for u64

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

impl DekuWrite<BitSize> for i64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroI16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for u8

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for u32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<BitSize> for u16

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl<Ctx: Copy, A: DekuWrite<Ctx>> DekuWrite<Ctx> for (A,)

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

impl DekuWrite<ByteSize> for i64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for usize

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<Endian> for f64

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

impl<Ctx> DekuWrite<Ctx> for boolwhere u8: DekuWrite<Ctx>,

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

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

impl DekuWrite<(Endian, BitSize)> for NonZeroI32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for f32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<BitSize> for f64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroI16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for i32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>, G: DekuWrite<Ctx>, H: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F, G, H)

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

impl DekuWrite<ByteSize> for i16

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl<Ctx> DekuWrite<Ctx> for Ipv6Addrwhere u128: DekuWrite<Ctx>,

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

impl DekuWrite<(Endian, BitSize)> for isize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<BitSize> for u64

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl<T, Ctx> DekuWrite<Ctx> for &Twhere T: DekuWrite<Ctx>, Ctx: Copy,

Implements DekuWrite for references of types that implement DekuWrite

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

Write value of type to bits

impl DekuWrite<(Endian, ByteSize)> for NonZeroU32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroU128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for i128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for u128

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

impl DekuWrite<Endian> for usize

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

impl DekuWrite<ByteSize> for u16

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<Endian> for NonZeroU8

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

impl DekuWrite<Endian> for i8

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

impl DekuWrite<()> for i128

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

impl DekuWrite<(Endian, ByteSize)> for u64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl<T: DekuWrite<Ctx>, S, Ctx: Copy> DekuWrite<Ctx> for HashSet<T, S>

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

Write all Ts in a HashSet to bits.

• inner_ctx - The context required by T. Note: depending on the Hasher S, the order in which the T’s are written may change between executions. Use a deterministic Hasher for your HashSet instead of the default RandomState hasher if you don’t want the order written to change.

Examples

let set: HashSet<u8> = vec![1].into_iter().collect();
let mut output = bitvec![u8, Msb0;];
set.write(&mut output, Endian::Big).unwrap();
assert_eq!(output, bitvec![u8, Msb0; 0, 0, 0, 0, 0, 0, 0, 1])

impl DekuWrite<BitSize> for usize

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for u128

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl<T: DekuWrite<Ctx>, Ctx: Copy> DekuWrite<Ctx> for Vec<T>

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

Write all Ts in a Vec to bits.

• inner_ctx - The context required by T.

Examples

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

impl<Ctx> DekuWrite<Ctx> for Ipv4Addrwhere u32: DekuWrite<Ctx>,

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>, G: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F, G)

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

impl DekuWrite<(Endian, BitSize)> for NonZeroU16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for u128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for NonZeroI64

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

impl DekuWrite<(Endian, BitSize)> for u128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl<T: DekuWrite<Ctx>, Ctx: Copy> DekuWrite<Ctx> for Option<T>

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

Write T if Some

• inner_ctx - The context required by T.

Examples

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

impl DekuWrite<()> for i64

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B)

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

impl DekuWrite<(Endian, BitSize)> for i8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroUsize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for i8

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<()> for u128

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

impl DekuWrite<(Endian, ByteSize)> for usize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroU8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for usize

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

impl<Ctx> DekuWrite<Ctx> for IpAddrwhere Ipv6Addr: DekuWrite<Ctx>, Ipv4Addr: DekuWrite<Ctx>,

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

impl DekuWrite<BitSize> for u32

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroI8

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

impl DekuWrite<(Endian, BitSize)> for u32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroI64

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

impl DekuWrite<(Endian, ByteSize)> for NonZeroI8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroU16

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

impl DekuWrite<Endian> for i128

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

impl DekuWrite<Endian> for NonZeroU16

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

impl DekuWrite<()> for i32

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

impl DekuWrite<Endian> for NonZeroU32

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

impl DekuWrite<(Endian, ByteSize)> for i8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for i64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<ByteSize> for isize

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: ByteSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroU16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<BitSize> for i128

fn write( &self, output: &mut BitVec<u8, Msb0>, bit_size: BitSize ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for NonZeroU128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for u16

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

impl DekuWrite<(Endian, BitSize)> for NonZeroI64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl<T, Ctx> DekuWrite<Ctx> for Cow<'_, T>where T: DekuWrite<Ctx> + Clone, Ctx: Copy,

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

Write T from Cow

impl DekuWrite<(Endian, ByteSize)> for NonZeroI32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for i64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroU32

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

impl DekuWrite<()> for NonZeroI16

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

impl DekuWrite<(Endian, BitSize)> for i16

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<Endian> for NonZeroI128

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

impl DekuWrite<Endian> for u64

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

impl DekuWrite<()> for u32

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

impl DekuWrite<(Endian, BitSize)> for NonZeroI8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for f64

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

impl DekuWrite<(Endian, ByteSize)> for NonZeroI64

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for NonZeroIsize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bytesize): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<()> for NonZeroU64

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

impl DekuWrite<(Endian, BitSize)> for NonZeroI128

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, bitsize): (Endian, BitSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, ByteSize)> for u8

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl DekuWrite<(Endian, BitSize)> for f32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E)

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

impl DekuWrite<(Endian, ByteSize)> for u32

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, ByteSize) ) -> Result<(), DekuError>

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>, G: DekuWrite<Ctx>, H: DekuWrite<Ctx>, I: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F, G, H, I)

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

impl<Ctx: Copy, A: DekuWrite<Ctx>, B: DekuWrite<Ctx>, C: DekuWrite<Ctx>, D: DekuWrite<Ctx>, E: DekuWrite<Ctx>, F: DekuWrite<Ctx>, G: DekuWrite<Ctx>, H: DekuWrite<Ctx>, I: DekuWrite<Ctx>, J: DekuWrite<Ctx>> DekuWrite<Ctx> for (A, B, C, D, E, F, G, H, I, J)

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

impl DekuWrite<(Endian, BitSize)> for usize

fn write( &self, output: &mut BitVec<u8, Msb0>, (endian, size): (Endian, BitSize) ) -> Result<(), DekuError>

Implementors