Struct musli::compat::Packed

#[repr(transparent)]
pub struct Packed<T>(pub T);

Treat T as if its packed.

This is for example implemented for tuples.

Examples

use musli::{Decode, Decoder};
use musli::compat::Packed;

struct Struct {
    field: u8,
    field2: u32,
}

impl<'de, M> Decode<'de, M> for Struct
where
    Packed<(u8, u32)>: Decode<'de, M>
{
    fn decode<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
    where
        D: Decoder<'de, Mode = M>,
    {
        let Packed((field, field2)) = Decode::decode(cx, decoder)?;

        Ok(Struct {
            field,
            field2,
        })
    }
}

Tuple Fields

0: T

Trait Implementations

impl<'de, T> Decode<'de, Binary> for Packed<T>

where T: EncodePacked<Binary> + DecodePacked<'de, Binary>,

fn decode<D>( _ctx: &D::Cx, _decoder: D ) -> Result<Self, <D::Cx as Context>::Error>

where D: Decoder<'de, Mode = Binary>,

Decode the given input.

impl<'de, T> Decode<'de, Text> for Packed<T>

where T: EncodePacked<Text> + DecodePacked<'de, Text>,

fn decode<D>( _ctx: &D::Cx, _decoder: D ) -> Result<Self, <D::Cx as Context>::Error>

where D: Decoder<'de, Mode = Text>,

Decode the given input.

impl<T> Encode<Binary> for Packed<T>

where T: EncodePacked<Binary>,

fn encode<E>( &self, _ctx: &E::Cx, _encoder: E ) -> Result<<E as Encoder>::Ok, <E as Encoder>::Error>

where E: Encoder<Mode = Binary>,

Encode the given output.

impl<T> Encode<Text> for Packed<T>

where T: EncodePacked<Text>,

fn encode<E>( &self, _ctx: &E::Cx, _encoder: E ) -> Result<<E as Encoder>::Ok, <E as Encoder>::Error>

where E: Encoder<Mode = Text>,

Encode the given output.