Trait packed_struct::PackedStruct

pub trait PackedStruct<B> where
    Self: Sized, {
    fn pack(&self) -> B;
    fn unpack(src: &B) -> Result<Self, PackingError>;
}

A structure that can be packed and unpacked from a byte array.

In case the structure occupies less bits than there are in the byte array, the packed that should be aligned to the end of the array, with leading bits being ignored.

10 bits packs into: [0b00000011, 0b11111111]

Required methods

fn pack(&self) -> B

Packs the structure into a byte array.

fn unpack(src: &B) -> Result<Self, PackingError>

Unpacks the structure from a byte array.

Loading content...

Implementations on Foreign Types

impl PackedStruct<[u8; 1]> for [u8; 1]

fn pack(&self) -> [u8; 1]

fn unpack(src: &[u8; 1]) -> Result<[u8; 1], PackingError>

impl PackedStruct<[u8; 2]> for [u8; 2]

fn pack(&self) -> [u8; 2]

fn unpack(src: &[u8; 2]) -> Result<[u8; 2], PackingError>

impl PackedStruct<[u8; 3]> for [u8; 3]

fn pack(&self) -> [u8; 3]

fn unpack(src: &[u8; 3]) -> Result<[u8; 3], PackingError>

impl PackedStruct<[u8; 4]> for [u8; 4]

fn pack(&self) -> [u8; 4]

fn unpack(src: &[u8; 4]) -> Result<[u8; 4], PackingError>

impl PackedStruct<[u8; 5]> for [u8; 5]

fn pack(&self) -> [u8; 5]

fn unpack(src: &[u8; 5]) -> Result<[u8; 5], PackingError>

impl PackedStruct<[u8; 6]> for [u8; 6]

fn pack(&self) -> [u8; 6]

fn unpack(src: &[u8; 6]) -> Result<[u8; 6], PackingError>

impl PackedStruct<[u8; 7]> for [u8; 7]

fn pack(&self) -> [u8; 7]

fn unpack(src: &[u8; 7]) -> Result<[u8; 7], PackingError>

impl PackedStruct<[u8; 8]> for [u8; 8]

fn pack(&self) -> [u8; 8]

fn unpack(src: &[u8; 8]) -> Result<[u8; 8], PackingError>

impl PackedStruct<[u8; 9]> for [u8; 9]

fn pack(&self) -> [u8; 9]

fn unpack(src: &[u8; 9]) -> Result<[u8; 9], PackingError>

impl PackedStruct<[u8; 10]> for [u8; 10]

fn pack(&self) -> [u8; 10]

fn unpack(src: &[u8; 10]) -> Result<[u8; 10], PackingError>

impl PackedStruct<[u8; 11]> for [u8; 11]

fn pack(&self) -> [u8; 11]

fn unpack(src: &[u8; 11]) -> Result<[u8; 11], PackingError>

impl PackedStruct<[u8; 12]> for [u8; 12]

fn pack(&self) -> [u8; 12]

fn unpack(src: &[u8; 12]) -> Result<[u8; 12], PackingError>

impl PackedStruct<[u8; 13]> for [u8; 13]

fn pack(&self) -> [u8; 13]

fn unpack(src: &[u8; 13]) -> Result<[u8; 13], PackingError>

impl PackedStruct<[u8; 14]> for [u8; 14]

fn pack(&self) -> [u8; 14]

fn unpack(src: &[u8; 14]) -> Result<[u8; 14], PackingError>

impl PackedStruct<[u8; 15]> for [u8; 15]

fn pack(&self) -> [u8; 15]

fn unpack(src: &[u8; 15]) -> Result<[u8; 15], PackingError>

impl PackedStruct<[u8; 16]> for [u8; 16]

fn pack(&self) -> [u8; 16]

fn unpack(src: &[u8; 16]) -> Result<[u8; 16], PackingError>

impl PackedStruct<[u8; 17]> for [u8; 17]

fn pack(&self) -> [u8; 17]

fn unpack(src: &[u8; 17]) -> Result<[u8; 17], PackingError>

impl PackedStruct<[u8; 18]> for [u8; 18]

fn pack(&self) -> [u8; 18]

fn unpack(src: &[u8; 18]) -> Result<[u8; 18], PackingError>

impl PackedStruct<[u8; 19]> for [u8; 19]

fn pack(&self) -> [u8; 19]

fn unpack(src: &[u8; 19]) -> Result<[u8; 19], PackingError>

impl PackedStruct<[u8; 20]> for [u8; 20]

fn pack(&self) -> [u8; 20]

fn unpack(src: &[u8; 20]) -> Result<[u8; 20], PackingError>

impl PackedStruct<[u8; 21]> for [u8; 21]

fn pack(&self) -> [u8; 21]

fn unpack(src: &[u8; 21]) -> Result<[u8; 21], PackingError>

impl PackedStruct<[u8; 22]> for [u8; 22]

fn pack(&self) -> [u8; 22]

fn unpack(src: &[u8; 22]) -> Result<[u8; 22], PackingError>

impl PackedStruct<[u8; 23]> for [u8; 23]

fn pack(&self) -> [u8; 23]

fn unpack(src: &[u8; 23]) -> Result<[u8; 23], PackingError>

impl PackedStruct<[u8; 24]> for [u8; 24]

fn pack(&self) -> [u8; 24]

fn unpack(src: &[u8; 24]) -> Result<[u8; 24], PackingError>

impl PackedStruct<[u8; 25]> for [u8; 25]

fn pack(&self) -> [u8; 25]

fn unpack(src: &[u8; 25]) -> Result<[u8; 25], PackingError>

impl PackedStruct<[u8; 26]> for [u8; 26]

fn pack(&self) -> [u8; 26]

fn unpack(src: &[u8; 26]) -> Result<[u8; 26], PackingError>

impl PackedStruct<[u8; 27]> for [u8; 27]

fn pack(&self) -> [u8; 27]

fn unpack(src: &[u8; 27]) -> Result<[u8; 27], PackingError>

impl PackedStruct<[u8; 28]> for [u8; 28]

fn pack(&self) -> [u8; 28]

fn unpack(src: &[u8; 28]) -> Result<[u8; 28], PackingError>

impl PackedStruct<[u8; 29]> for [u8; 29]

fn pack(&self) -> [u8; 29]

fn unpack(src: &[u8; 29]) -> Result<[u8; 29], PackingError>

impl PackedStruct<[u8; 30]> for [u8; 30]

fn pack(&self) -> [u8; 30]

fn unpack(src: &[u8; 30]) -> Result<[u8; 30], PackingError>

impl PackedStruct<[u8; 31]> for [u8; 31]

fn pack(&self) -> [u8; 31]

fn unpack(src: &[u8; 31]) -> Result<[u8; 31], PackingError>

impl PackedStruct<[u8; 32]> for [u8; 32]

fn pack(&self) -> [u8; 32]

fn unpack(src: &[u8; 32]) -> Result<[u8; 32], PackingError>

impl PackedStruct<[u8; 1]> for bool

fn pack(&self) -> [u8; 1]

fn unpack(src: &[u8; 1]) -> Result<bool, PackingError>

impl PackedStruct<[u8; 1]> for u8

fn pack(&self) -> [u8; 1]

fn unpack(src: &[u8; 1]) -> Result<u8, PackingError>

impl PackedStruct<[u8; 1]> for i8

fn pack(&self) -> [u8; 1]

fn unpack(src: &[u8; 1]) -> Result<i8, PackingError>

impl PackedStruct<[u8; 0]> for ()

fn pack(&self) -> [u8; 0]

fn unpack(_src: &[u8; 0]) -> Result<(), PackingError>

Loading content...

Implementors

impl<T, B, I> PackedStruct<<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes> for LsbInteger<T, B, I> where
    B: NumberOfBits,
    I: SizedInteger<T, B>,
    B: BitsFullBytes, 

fn pack(&self) -> <<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes

fn unpack(
    src: &<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes
) -> Result<Self, PackingError>

impl<T, B, I> PackedStruct<<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes> for MsbInteger<T, B, I> where
    B: NumberOfBits,
    I: SizedInteger<T, B>, 

fn pack(&self) -> <<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes

fn unpack(
    src: &<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes
) -> Result<Self, PackingError>

impl<V, B> PackedStruct<<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes> for ReservedBits<V, B> where
    Self: Default,
    V: ReservedBitValue,
    B: NumberOfBits, 

fn pack(&self) -> <<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes

fn unpack(
    _src: &<<B as NumberOfBits>::Bytes as NumberOfBytes>::AsBytes
) -> Result<Self, PackingError>

Loading content...