Trait amadeus_serde::SerdeData

pub trait SerdeData where
    Self: Clone + PartialEq + Debug + 'static, {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer;
    fn deserialize<'de, D>(
        deserializer: D, 
        schema: Option<SchemaIncomplete>
    ) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>;
}

Required methods

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Loading content...

Implementations on Foreign Types

impl SerdeData for bool

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for u8

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for i8

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for u16

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for i16

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for u32

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for i32

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for u64

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for i64

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for f32

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for f64

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Bson

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for String

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Enum

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Json

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Decimal

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Date

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for DateWithoutTimezone

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Time

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for TimeWithoutTimezone

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for DateTime

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for DateTimeWithoutTimezone

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Timezone

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Webpage<'static>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Url

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for IpAddr

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for Option<T> where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Group

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T: Data> SerdeData for List<T> where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<K, V, S> SerdeData for HashMap<K, V, S> where
    K: Hash + Eq + SerdeData,
    V: SerdeData,
    S: BuildHasher + Clone + 'static, 

fn serialize<S1>(&self, _serializer: S1) -> Result<S1::Ok, S1::Error> where
    S1: Serializer, 

fn deserialize<'de, D>(
    _deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for Value

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 0] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 1] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 2] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 3] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 4] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 5] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 6] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 7] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 8] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 9] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 10] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 11] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 12] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 13] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 14] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 15] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 16] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 17] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 18] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 19] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 20] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 21] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 22] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 23] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 24] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 25] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 26] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 27] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 28] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 29] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 30] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 31] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<T> SerdeData for [T; 32] where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl SerdeData for ()

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A> SerdeData for (A,) where
    A: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B> SerdeData for (A, B) where
    A: SerdeData,
    B: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C> SerdeData for (A, B, C) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D> SerdeData for (A, B, C, D) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E> SerdeData for (A, B, C, D, E) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F> SerdeData for (A, B, C, D, E, F) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G> SerdeData for (A, B, C, D, E, F, G) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G, H> SerdeData for (A, B, C, D, E, F, G, H) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData,
    H: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G, H, I> SerdeData for (A, B, C, D, E, F, G, H, I) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData,
    H: SerdeData,
    I: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G, H, I, J> SerdeData for (A, B, C, D, E, F, G, H, I, J) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData,
    H: SerdeData,
    I: SerdeData,
    J: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G, H, I, J, K> SerdeData for (A, B, C, D, E, F, G, H, I, J, K) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData,
    H: SerdeData,
    I: SerdeData,
    J: SerdeData,
    K: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L> SerdeData for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: SerdeData,
    B: SerdeData,
    C: SerdeData,
    D: SerdeData,
    E: SerdeData,
    F: SerdeData,
    G: SerdeData,
    H: SerdeData,
    I: SerdeData,
    J: SerdeData,
    K: SerdeData,
    L: SerdeData, 

fn serialize<S_>(&self, serializer: S_) -> Result<S_::Ok, S_::Error> where
    S_: Serializer, 

fn deserialize<'de, D_>(
    deserializer: D_,
    _schema: Option<SchemaIncomplete>
) -> Result<Self, D_::Error> where
    D_: Deserializer<'de>, 

impl<T> SerdeData for Box<T> where
    T: SerdeData, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    deserializer: D,
    schema: Option<SchemaIncomplete>
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Loading content...

Implementors

Loading content...