Struct SerdeLite 

pub struct SerdeLite<C>(/* private fields */);

A wrapper codec that relies on serde_lite. With this, you can wrap serde based codecs that also work with serde-lite like the [JsonSerdeCodec] or the [MsgpackSerdeCodec].

Only available with the serde_lite feature enabled plus the feature you need for the wrapped codec.

Example

use codee::{Encoder, Decoder, SerdeLite, string::JsonSerdeCodec, binary::MsgpackSerdeCodec};
use serde_lite::{Deserialize, Serialize};

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct Test {
    s: String,
    i: i32,
}

let t = Test {
    s: String::from("party time 🎉"),
    i: 42,
};

let enc = SerdeLite::<JsonSerdeCodec>::encode(&t).unwrap();
let dec: Test = SerdeLite::<JsonSerdeCodec>::decode(&enc).unwrap();

let enc = SerdeLite::<MsgpackSerdeCodec>::encode(&t).unwrap();
let dec: Test = SerdeLite::<MsgpackSerdeCodec>::decode(&enc).unwrap();
assert_eq!(dec, t);

Trait Implementations

impl<T, D> Decoder<T> for SerdeLite<D>

where T: Deserialize, D: Decoder<Intermediate>,

type Error = SerdeLiteDecodeError<<D as Decoder<Intermediate>>::Error>

type Encoded = <D as Decoder<Intermediate>>::Encoded

fn decode( val: &<SerdeLite<D> as Decoder<T>>::Encoded, ) -> Result<T, <SerdeLite<D> as Decoder<T>>::Error>

impl<T, E> Encoder<T> for SerdeLite<E>

where T: Serialize, E: Encoder<Intermediate>,

type Error = SerdeLiteEncodeError<<E as Encoder<Intermediate>>::Error>

type Encoded = <E as Encoder<Intermediate>>::Encoded

fn encode( val: &T, ) -> Result<<SerdeLite<E> as Encoder<T>>::Encoded, <SerdeLite<E> as Encoder<T>>::Error>