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 Vec<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 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 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 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 [u8; 0]

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; 1]

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; 2]

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; 3]

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; 4]

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; 5]

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; 6]

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; 7]

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; 8]

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; 9]

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; 10]

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; 11]

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; 12]

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; 13]

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; 14]

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; 15]

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; 16]

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; 17]

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; 18]

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; 19]

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; 20]

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; 21]

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; 22]

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; 23]

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; 24]

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; 25]

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; 26]

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; 27]

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; 28]

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; 29]

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; 30]

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; 31]

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; 32]

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 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 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> 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> SerdeData for Map<K, V> where
    K: Hash + Eq + SerdeData,
    V: 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 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 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 Timestamp

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 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 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 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<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<T> SerdeData for Box<T> where
    T: SerdeData, 

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

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

Loading content...

Implementors

Loading content...