Trait serde_schema::SchemaSerialize

pub trait SchemaSerialize: Serialize {
    fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>;
}

Required Methods

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

Implementations on Foreign Types

impl SchemaSerialize for bool

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for i8

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for i16

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for i32

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for i64

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for isize

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for u8

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for u16

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for u32

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for u64

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for usize

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for f32

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for f64

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for char

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for str

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for String

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for Option<T>

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for PhantomData<T>

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 0]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 1]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 2]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 3]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 4]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 5]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 6]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 7]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 8]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 9]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 10]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 11]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 12]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 13]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 14]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 15]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 16]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 17]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 18]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 19]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 20]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 21]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 22]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 23]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 24]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 25]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 26]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 27]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 28]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 29]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 30]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 31]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T; 32]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize> SchemaSerialize for [T]

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for BinaryHeap<T>where
    T: SchemaSerialize + Ord,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for BTreeSet<T>where
    T: SchemaSerialize + Ord,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T, H> SchemaSerialize for HashSet<T, H>where
    T: SchemaSerialize + Eq + Hash,
    H: BuildHasher,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for LinkedList<T>where
    T: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for Vec<T>where
    T: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T> SchemaSerialize for VecDeque<T>where
    T: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<Idx: SchemaSerialize> SchemaSerialize for Range<Idx>

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl SchemaSerialize for ()

fn schema_register<S: Schema>(_: &mut S) -> Result<S::TypeId, S::Error>

impl<T0> SchemaSerialize for (T0,)where
    T0: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1> SchemaSerialize for (T0, T1)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2> SchemaSerialize for (T0, T1, T2)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3> SchemaSerialize for (T0, T1, T2, T3)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4> SchemaSerialize for (T0, T1, T2, T3, T4)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5> SchemaSerialize for (T0, T1, T2, T3, T4, T5)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,
    T11: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,
    T11: SchemaSerialize,
    T12: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,
    T11: SchemaSerialize,
    T12: SchemaSerialize,
    T13: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,
    T11: SchemaSerialize,
    T12: SchemaSerialize,
    T13: SchemaSerialize,
    T14: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SchemaSerialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)where
    T0: SchemaSerialize,
    T1: SchemaSerialize,
    T2: SchemaSerialize,
    T3: SchemaSerialize,
    T4: SchemaSerialize,
    T5: SchemaSerialize,
    T6: SchemaSerialize,
    T7: SchemaSerialize,
    T8: SchemaSerialize,
    T9: SchemaSerialize,
    T10: SchemaSerialize,
    T11: SchemaSerialize,
    T12: SchemaSerialize,
    T13: SchemaSerialize,
    T14: SchemaSerialize,
    T15: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<K, V> SchemaSerialize for BTreeMap<K, V>where
    K: SchemaSerialize + Ord,
    V: SchemaSerialize,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<K, V, H> SchemaSerialize for HashMap<K, V, H>where
    K: SchemaSerialize + Eq + Hash,
    V: SchemaSerialize,
    H: BuildHasher,

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<'a, T: SchemaSerialize + ?Sized> SchemaSerialize for &'a T

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<'a, T: SchemaSerialize + ?Sized> SchemaSerialize for &'a mut T

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<T: SchemaSerialize + ?Sized> SchemaSerialize for Box<T>

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

impl<'a, T: SchemaSerialize + ToOwned + ?Sized> SchemaSerialize for Cow<'a, T>

fn schema_register<S: Schema>(schema: &mut S) -> Result<S::TypeId, S::Error>

Implementors