Trait SchemaRead 

pub unsafe trait SchemaRead<'de, C: ConfigCore> {
    type Dst;

    const TYPE_META: TypeMeta = TypeMeta::Dynamic;

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

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

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

Safety

Implementors must adhere to the Safety section of the associated constant TYPE_META (or leave it as the default) and the method read.

Provided Associated Constants

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.

Safety

It is always safe to leave this as the default TypeMeta::Dynamic. If you set it to TypeMeta::Static { size, zero_copy }, you have to ensure the following two points:

• size must always correspond to the number of bytes read by read.
• If zero_copy is true, Dst’s in-memory representation must correspond exactly to the serialized form, and all byte sequences must be valid in-memory representations of Dst.

Required Associated Types

type Dst

Required Methods

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

Read into dst from reader.

Safety

You must initialize dst if and only if you return Ok(()). In the Err(…) case, initializing dst can lead to memory leaks.

It is permissible to not initialize dst if dst is an inhabited zero-sized type.

Provided Methods

fn get(reader: 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, C: Config> SchemaRead<'de, C> for &'de str

type Dst = &'de str

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

impl<'de, C: Config> SchemaRead<'de, C> for IpAddr

type Dst = IpAddr

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

impl<'de, C: Config> SchemaRead<'de, C> for SocketAddr

type Dst = SocketAddr

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

impl<'de, C: Config> SchemaRead<'de, C> for String

Available on crate feature alloc only.

type Dst = String

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

impl<'de, C: Config> SchemaRead<'de, C> for Bytes

Available on crate feature bytes only.

type Dst = Bytes

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

impl<'de, C: Config> SchemaRead<'de, C> for BytesMut

Available on crate feature bytes only.

type Dst = BytesMut

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

impl<'de, C: Config> SchemaRead<'de, C> for EcoString

Available on crate feature ecow only.

type Dst = EcoString

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

impl<'de, C: Config> SchemaRead<'de, C> for Uuid

Available on crate feature uuid only.

type Dst = Uuid

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

impl<'de, C: Config, Block: BlockType + SchemaRead<'de, C, Dst = Block>> SchemaRead<'de, C> for BitVec<Block>

Available on crate feature bv only.

type Dst = BitVec<Block>

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

impl<'de, C: Config, K> SchemaRead<'de, C> for BTreeSet<K>

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

Available on crate feature alloc only.

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

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

impl<'de, C: Config, K> SchemaRead<'de, C> for LinkedList<K>

where K: SchemaRead<'de, C>,

Available on crate feature alloc only.

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

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

impl<'de, C: Config, K, S> SchemaRead<'de, C> for HashSet<K, S>

where K: SchemaRead<'de, C>, K::Dst: Hash + Eq, S: BuildHasher + Default,

Available on crate feature std only.

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

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

impl<'de, C: Config, K, S> SchemaRead<'de, C> for IndexSet<K, S>

where K: SchemaRead<'de, C>, K::Dst: Hash + Eq, S: BuildHasher + Default,

Available on crate feature indexmap only.

type Dst = IndexSet<<K as SchemaRead<'de, C>>::Dst, S>

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

impl<'de, C: Config, K, V> SchemaRead<'de, C> for BTreeMap<K, V>

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

Available on crate feature alloc only.

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

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

impl<'de, C: Config, K, V, S> SchemaRead<'de, C> for HashMap<K, V, S>

where K: SchemaRead<'de, C>, V: SchemaRead<'de, C>, K::Dst: Hash + Eq, S: BuildHasher + Default,

Available on crate feature std only.

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

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

impl<'de, C: Config, K, V, S> SchemaRead<'de, C> for IndexMap<K, V, S>

where K: SchemaRead<'de, C>, V: SchemaRead<'de, C>, K::Dst: Hash + Eq, S: BuildHasher + Default,

Available on crate feature indexmap only.

type Dst = IndexMap<<K as SchemaRead<'de, C>>::Dst, <V as SchemaRead<'de, C>>::Dst, S>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for bool

const TYPE_META: TypeMeta

type Dst = bool

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for char

type Dst = char

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for f32

const TYPE_META: TypeMeta

type Dst = f32

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for f64

const TYPE_META: TypeMeta

type Dst = f64

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for i8

const TYPE_META: TypeMeta

type Dst = i8

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for i16

const TYPE_META: TypeMeta

type Dst = i16

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for i32

const TYPE_META: TypeMeta

type Dst = i32

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for i64

const TYPE_META: TypeMeta

type Dst = i64

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for i128

const TYPE_META: TypeMeta

type Dst = i128

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for isize

const TYPE_META: TypeMeta

type Dst = isize

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for u8

const TYPE_META: TypeMeta

type Dst = u8

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for u16

const TYPE_META: TypeMeta

type Dst = u16

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for u32

const TYPE_META: TypeMeta

type Dst = u32

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for u64

const TYPE_META: TypeMeta

type Dst = u64

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for u128

const TYPE_META: TypeMeta

type Dst = u128

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for ()

const TYPE_META: TypeMeta

type Dst = ()

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for usize

const TYPE_META: TypeMeta

type Dst = usize

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for Ipv4Addr

const TYPE_META: TypeMeta

type Dst = Ipv4Addr

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for Ipv6Addr

const TYPE_META: TypeMeta

type Dst = Ipv6Addr

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for SocketAddrV4

const TYPE_META: TypeMeta

type Dst = SocketAddrV4

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for SocketAddrV6

const TYPE_META: TypeMeta

type Dst = SocketAddrV6

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for Duration

const TYPE_META: TypeMeta

type Dst = Duration

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for SystemTime

Available on crate feature std only.

const TYPE_META: TypeMeta

type Dst = SystemTime

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroI8

const TYPE_META: TypeMeta

type Dst = NonZero<i8>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroI16

const TYPE_META: TypeMeta

type Dst = NonZero<i16>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroI32

const TYPE_META: TypeMeta

type Dst = NonZero<i32>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroI64

const TYPE_META: TypeMeta

type Dst = NonZero<i64>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroI128

const TYPE_META: TypeMeta

type Dst = NonZero<i128>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroIsize

const TYPE_META: TypeMeta

type Dst = NonZero<isize>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroU8

const TYPE_META: TypeMeta

type Dst = NonZero<u8>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroU16

const TYPE_META: TypeMeta

type Dst = NonZero<u16>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroU32

const TYPE_META: TypeMeta

type Dst = NonZero<u32>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroU64

const TYPE_META: TypeMeta

type Dst = NonZero<u64>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroU128

const TYPE_META: TypeMeta

type Dst = NonZero<u128>

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

impl<'de, C: ConfigCore> SchemaRead<'de, C> for NonZeroUsize

const TYPE_META: TypeMeta

type Dst = NonZero<usize>

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

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

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

const TYPE_META: TypeMeta

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

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

impl<'de, Idx, C: ConfigCore> SchemaRead<'de, C> for Range<Idx>

where Idx: SchemaRead<'de, C>,

const TYPE_META: TypeMeta

type Dst = Range<<Idx as SchemaRead<'de, C>>::Dst>

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

impl<'de, Idx, C: ConfigCore> SchemaRead<'de, C> for RangeInclusive<Idx>

where Idx: SchemaRead<'de, C>,

const TYPE_META: TypeMeta

type Dst = RangeInclusive<<Idx as SchemaRead<'de, C>>::Dst>

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

impl<'de, T, C: Config> SchemaRead<'de, C> for &'de [T]

where T: SchemaRead<'de, C> + ZeroCopy<C>,

const TYPE_META: TypeMeta

type Dst = &'de [<T as SchemaRead<'de, C>>::Dst]

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

impl<'de, T, C: Config> SchemaRead<'de, C> for &'de mut [T]

where T: SchemaRead<'de, C> + ZeroCopy<C>,

const TYPE_META: TypeMeta

type Dst = &'de mut [<T as SchemaRead<'de, C>>::Dst]

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

impl<'de, T, C: Config> SchemaRead<'de, C> for Bound<T>

where T: SchemaRead<'de, C>,

type Dst = Bound<<T as SchemaRead<'de, C>>::Dst>

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

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

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

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

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

impl<'de, T, C: Config> SchemaRead<'de, C> for BinaryHeap<T>

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

Available on crate feature alloc only.

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

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

impl<'de, T, C: Config> SchemaRead<'de, C> for VecDeque<T>

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

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

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

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

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

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

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

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

where T: SchemaRead<'de, C>,

Available on crate feature alloc and target_has_atomic=ptr only.

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

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

impl<'de, T, C: Config> SchemaRead<'de, C> for Vec<T>

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

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

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for Cow<'de, T>

where T: ToOwned + ?Sized, &'de T: SchemaRead<'de, C, Dst = &'de T>, T::Owned: SchemaRead<'de, C, Dst = T::Owned>,

Available on crate feature alloc only.

type Dst = Cow<'de, T>

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for Option<T>

where T: SchemaRead<'de, C>,

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

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for &'de T

where T: SchemaRead<'de, C> + ZeroCopy<C>,

const TYPE_META: TypeMeta

type Dst = &'de <T as SchemaRead<'de, C>>::Dst

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for &'de mut T

where T: SchemaRead<'de, C> + ZeroCopy<C>,

const TYPE_META: TypeMeta

type Dst = &'de mut <T as SchemaRead<'de, C>>::Dst

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for Box<T>

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

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

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for Rc<T>

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

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

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for Arc<T>

where T: SchemaRead<'de, C>,

Available on crate feature alloc only.

const TYPE_META: TypeMeta

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

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

impl<'de, T, C: ConfigCore> SchemaRead<'de, C> for PhantomData<T>

const TYPE_META: TypeMeta

type Dst = PhantomData<T>

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

impl<'de, T, E, C: Config> SchemaRead<'de, C> for Result<T, E>

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

const TYPE_META: TypeMeta

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

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

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

where T: SchemaRead<'de, C>,

Available on crate feature smallvec only.

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

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

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

where T: SchemaRead<'de, C>,

const TYPE_META: TypeMeta

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

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

Implementors

impl<'de, C: ConfigCore> SchemaRead<'de, C> for ShortU16

Available on crate feature solana-short-vec only.

type Dst = ShortU16

impl<'de, Coll, Len, C: ConfigCore> SchemaRead<'de, C> for FromIntoIterator<Coll, Len>

where Len: SeqLen<C>, Coll: IntoIterator<Item: SchemaRead<'de, C>> + FromIterator<<Coll::Item as SchemaRead<'de, C>>::Dst>,

type Dst = Coll

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

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

Available on crate feature alloc only.

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

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

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

Available on crate feature alloc only.

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

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

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

Available on crate feature alloc only.

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

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

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

Available on crate feature alloc only.

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

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

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

Available on crate feature alloc only.

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

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

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

Available on crate feature alloc only.

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