Trait SchemaRead 

pub trait SchemaRead<'de> {
    type Dst;

    const TYPE_META: TypeMeta = TypeMeta::Dynamic;

    // Required method
    fn read(
        reader: &mut impl Reader<'de>,
        dst: &mut MaybeUninit<Self::Dst>,
    ) -> ReadResult<()>;

    // Provided method
    fn get(reader: &mut impl Reader<'de>) -> ReadResult<Self::Dst> { ... }
}

Types that can be read (deserialized) from a Reader.

Provided Associated Constants

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Required Associated Types

type Dst

Required Methods

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

Safety

• Implementation must properly initialize the Self::Dst.

Provided Methods

fn get(reader: &mut impl Reader<'de>) -> ReadResult<Self::Dst>

Read Self::Dst from reader into a new Self::Dst.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'de> SchemaRead<'de> for &'de str

type Dst = &'de str

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for &'de [u8]

type Dst = &'de [u8]

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for bool

const TYPE_META: TypeMeta

type Dst = bool

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for char

type Dst = char

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for f32

const TYPE_META: TypeMeta

type Dst = f32

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for f64

const TYPE_META: TypeMeta

type Dst = f64

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for i8

const TYPE_META: TypeMeta

type Dst = i8

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for i16

const TYPE_META: TypeMeta

type Dst = i16

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for i32

const TYPE_META: TypeMeta

type Dst = i32

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for i64

const TYPE_META: TypeMeta

type Dst = i64

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for i128

const TYPE_META: TypeMeta

type Dst = i128

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for isize

const TYPE_META: TypeMeta

type Dst = isize

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for u8

const TYPE_META: TypeMeta

type Dst = u8

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for u16

const TYPE_META: TypeMeta

type Dst = u16

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for u32

const TYPE_META: TypeMeta

type Dst = u32

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for u64

const TYPE_META: TypeMeta

type Dst = u64

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for u128

const TYPE_META: TypeMeta

type Dst = u128

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for ()

const TYPE_META: TypeMeta

type Dst = ()

fn read( _reader: &mut impl Reader<'de>, _dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for usize

const TYPE_META: TypeMeta

type Dst = usize

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de> SchemaRead<'de> for String

Available on crate feature alloc only.

type Dst = String

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B> SchemaRead<'de> for (A, B)

where A: SchemaRead<'de>, B: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C> SchemaRead<'de> for (A, B, C)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D> SchemaRead<'de> for (A, B, C, D)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E> SchemaRead<'de> for (A, B, C, D, E)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F> SchemaRead<'de> for (A, B, C, D, E, F)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G> SchemaRead<'de> for (A, B, C, D, E, F, G)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H> SchemaRead<'de> for (A, B, C, D, E, F, G, H)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>, L: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst, <L as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>, L: SchemaRead<'de>, M: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst, <L as SchemaRead<'de>>::Dst, <M as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>, L: SchemaRead<'de>, M: SchemaRead<'de>, N: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst, <L as SchemaRead<'de>>::Dst, <M as SchemaRead<'de>>::Dst, <N as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>, L: SchemaRead<'de>, M: SchemaRead<'de>, N: SchemaRead<'de>, O: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst, <L as SchemaRead<'de>>::Dst, <M as SchemaRead<'de>>::Dst, <N as SchemaRead<'de>>::Dst, <O as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> SchemaRead<'de> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: SchemaRead<'de>, B: SchemaRead<'de>, C: SchemaRead<'de>, D: SchemaRead<'de>, E: SchemaRead<'de>, F: SchemaRead<'de>, G: SchemaRead<'de>, H: SchemaRead<'de>, I: SchemaRead<'de>, J: SchemaRead<'de>, K: SchemaRead<'de>, L: SchemaRead<'de>, M: SchemaRead<'de>, N: SchemaRead<'de>, O: SchemaRead<'de>, P: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = (<A as SchemaRead<'de>>::Dst, <B as SchemaRead<'de>>::Dst, <C as SchemaRead<'de>>::Dst, <D as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst, <F as SchemaRead<'de>>::Dst, <G as SchemaRead<'de>>::Dst, <H as SchemaRead<'de>>::Dst, <I as SchemaRead<'de>>::Dst, <J as SchemaRead<'de>>::Dst, <K as SchemaRead<'de>>::Dst, <L as SchemaRead<'de>>::Dst, <M as SchemaRead<'de>>::Dst, <N as SchemaRead<'de>>::Dst, <O as SchemaRead<'de>>::Dst, <P as SchemaRead<'de>>::Dst)

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, K> SchemaRead<'de> for BTreeSet<K>

where K: SchemaRead<'de>, K::Dst: Ord,

Available on crate feature alloc only.

type Dst = BTreeSet<<K as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, K> SchemaRead<'de> for LinkedList<K>

where K: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = LinkedList<<K as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, K> SchemaRead<'de> for HashSet<K>

where K: SchemaRead<'de>, K::Dst: Hash + Eq,

Available on crate feature std only.

type Dst = HashSet<<K as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, K, V> SchemaRead<'de> for BTreeMap<K, V>

where K: SchemaRead<'de>, V: SchemaRead<'de>, K::Dst: Ord,

Available on crate feature alloc only.

type Dst = BTreeMap<<K as SchemaRead<'de>>::Dst, <V as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, K, V> SchemaRead<'de> for HashMap<K, V>

where K: SchemaRead<'de>, V: SchemaRead<'de>, K::Dst: Hash + Eq,

Available on crate feature std only.

type Dst = HashMap<<K as SchemaRead<'de>>::Dst, <V as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Option<T>

where T: SchemaRead<'de>,

type Dst = Option<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Box<[T]>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Box<[<T as SchemaRead<'de>>::Dst]>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Box<T>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

type Dst = Box<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for BinaryHeap<T>

where T: SchemaRead<'de>, T::Dst: Ord,

Available on crate feature alloc only.

type Dst = BinaryHeap<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for VecDeque<T>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = VecDeque<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Rc<[T]>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Rc<[<T as SchemaRead<'de>>::Dst]>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Rc<T>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

type Dst = Rc<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Arc<[T]>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Arc<[<T as SchemaRead<'de>>::Dst]>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Arc<T>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

type Dst = Arc<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for Vec<T>

where T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Vec<<T as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T> SchemaRead<'de> for PhantomData<T>

const TYPE_META: TypeMeta

type Dst = PhantomData<T>

fn read( _reader: &mut impl Reader<'de>, _dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T, E> SchemaRead<'de> for Result<T, E>

where T: SchemaRead<'de>, E: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = Result<<T as SchemaRead<'de>>::Dst, <E as SchemaRead<'de>>::Dst>

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

impl<'de, T, const N: usize> SchemaRead<'de> for [T; N]

where T: SchemaRead<'de>,

const TYPE_META: TypeMeta

type Dst = [<T as SchemaRead<'de>>::Dst; N]

fn read( reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Implementors

impl<'de, T> SchemaRead<'de> for Elem<T>

where T: SchemaRead<'de>,

const TYPE_META: TypeMeta = T::TYPE_META

type Dst = <T as SchemaRead<'de>>::Dst

impl<'de, T> SchemaRead<'de> for Pod<T>

where T: Copy + 'static,

const TYPE_META: TypeMeta

type Dst = T

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::Arc<[T], Len>

where Len: SeqLen, T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Arc<[<T as SchemaRead<'de>>::Dst]>

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::BinaryHeap<T, Len>

where Len: SeqLen, T: SchemaRead<'de>, T::Dst: Ord,

Available on crate feature alloc only.

type Dst = BinaryHeap<<T as SchemaRead<'de>>::Dst>

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::Box<[T], Len>

where Len: SeqLen, T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Box<[<T as SchemaRead<'de>>::Dst]>

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::Rc<[T], Len>

where Len: SeqLen, T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Rc<[<T as SchemaRead<'de>>::Dst]>

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::Vec<T, Len>

where Len: SeqLen, T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = Vec<<T as SchemaRead<'de>>::Dst>

impl<'de, T, Len> SchemaRead<'de> for wincode::containers::VecDeque<T, Len>

where Len: SeqLen, T: SchemaRead<'de>,

Available on crate feature alloc only.

type Dst = VecDeque<<T as SchemaRead<'de>>::Dst>