Struct Codec 

pub struct Codec<F, G>(/* private fields */);

Adapter to pair a serialization adapter with a deserialization adapter

This adapter serializes with F and deserializes with G.

Example

use serde::{Deserialize, Serialize};
use serde_json::json;

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct Foo {
    #[serde(with = "serdapt::Codec::<serdapt::TryInto<u32>, serdapt::TryFrom<u32>>")]
    c: char,
}

let foo = Foo { c: 'a' };
let serialized = serde_json::to_value(&foo).unwrap();
assert_eq!(serialized, json!({ "c": b'a' }));
let deserialized = serde_json::from_value::<Foo>(serialized).unwrap();
assert_eq!(deserialized, foo);

Implementations

impl<F, G> Codec<F, G>

pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>

where T: ?Sized, S: Serializer, Self: SerializeWith<T>,

Serializes value with adapter

pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>

where D: Deserializer<'de>, Self: DeserializeWith<'de, T>,

Deserializes value with adapter

Trait Implementations

impl<'de, F, G, T> DeserializeWith<'de, T> for Codec<F, G>

where G: DeserializeWith<'de, T>,

fn deserialize_with<D>(deserializer: D) -> Result<T, D::Error>

where D: Deserializer<'de>,

Deserializes a value using deserializer

impl<F, G, T> SerializeWith<T> for Codec<F, G>

where F: SerializeWith<T>, T: ?Sized,

fn serialize_with<S: Serializer>( value: &T, serializer: S, ) -> Result<S::Ok, S::Error>

Serializes value using serializer