Trait Decode 

pub trait Decode: Sized {
    // Required methods
    fn decode(reader: &mut impl Decoder) -> Result<Self, Error>;
    async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Self, Error>;
}

Required Methods

fn decode(reader: &mut impl Decoder) -> Result<Self, Error>

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Self, Error>

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 Decode for bool

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<bool, Error>

fn decode(reader: &mut impl Decoder) -> Result<bool, Error>

impl Decode for f32

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<f32, Error>

fn decode(reader: &mut impl Decoder) -> Result<f32, Error>

impl Decode for f64

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<f64, Error>

fn decode(reader: &mut impl Decoder) -> Result<f64, Error>

impl Decode for i8

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<i8, Error>

fn decode(reader: &mut impl Decoder) -> Result<i8, Error>

impl Decode for i16

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<i16, Error>

fn decode(reader: &mut impl Decoder) -> Result<i16, Error>

impl Decode for i32

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<i32, Error>

fn decode(reader: &mut impl Decoder) -> Result<i32, Error>

impl Decode for i64

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<i64, Error>

fn decode(reader: &mut impl Decoder) -> Result<i64, Error>

impl Decode for i128

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<i128, Error>

fn decode(reader: &mut impl Decoder) -> Result<i128, Error>

impl Decode for isize

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<isize, Error>

fn decode(reader: &mut impl Decoder) -> Result<isize, Error>

impl Decode for u8

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<u8, Error>

fn decode(reader: &mut impl Decoder) -> Result<u8, Error>

impl Decode for u16

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<u16, Error>

fn decode(reader: &mut impl Decoder) -> Result<u16, Error>

impl Decode for u32

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<u32, Error>

fn decode(reader: &mut impl Decoder) -> Result<u32, Error>

impl Decode for u64

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<u64, Error>

fn decode(reader: &mut impl Decoder) -> Result<u64, Error>

impl Decode for u128

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<u128, Error>

fn decode(reader: &mut impl Decoder) -> Result<u128, Error>

impl Decode for ()

async fn decode_async(_: &mut impl AsyncDecoder) -> Result<(), Error>

fn decode(_: &mut impl Decoder) -> Result<(), Error>

impl Decode for usize

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<usize, Error>

fn decode(reader: &mut impl Decoder) -> Result<usize, Error>

impl Decode for String

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<String, Error>

fn decode(reader: &mut impl Decoder) -> Result<String, Error>

impl Decode for Bytes

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Bytes, Error>

fn decode(reader: &mut impl Decoder) -> Result<Bytes, Error>

impl<K> Decode for BTreeSet<K>

where K: Decode + Ord,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<BTreeSet<K>, Error>

fn decode(reader: &mut impl Decoder) -> Result<BTreeSet<K>, Error>

impl<K> Decode for HashSet<K>

where K: Decode + Eq + Hash,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<HashSet<K>, Error>

fn decode(reader: &mut impl Decoder) -> Result<HashSet<K>, Error>

impl<K, V> Decode for BTreeMap<K, V>

where K: Decode + Ord, V: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<BTreeMap<K, V>, Error>

fn decode(reader: &mut impl Decoder) -> Result<BTreeMap<K, V>, Error>

impl<K, V> Decode for HashMap<K, V>

where K: Decode + Eq + Hash, V: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<HashMap<K, V>, Error>

fn decode(reader: &mut impl Decoder) -> Result<HashMap<K, V>, Error>

impl<T0, T1> Decode for (T0, T1)

where T0: Decode, T1: Decode,

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<(T0, T1), Error>

fn decode(reader: &mut impl Decoder) -> Result<(T0, T1), Error>

impl<T0, T1, T2> Decode for (T0, T1, T2)

where T0: Decode, T1: Decode, T2: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2), Error>

fn decode(reader: &mut impl Decoder) -> Result<(T0, T1, T2), Error>

impl<T0, T1, T2, T3> Decode for (T0, T1, T2, T3)

where T0: Decode, T1: Decode, T2: Decode, T3: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3), Error>

fn decode(reader: &mut impl Decoder) -> Result<(T0, T1, T2, T3), Error>

impl<T0, T1, T2, T3, T4> Decode for (T0, T1, T2, T3, T4)

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4), Error>

fn decode(reader: &mut impl Decoder) -> Result<(T0, T1, T2, T3, T4), Error>

impl<T0, T1, T2, T3, T4, T5> Decode for (T0, T1, T2, T3, T4, T5)

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode, T5: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4, T5), Error>

fn decode(reader: &mut impl Decoder) -> Result<(T0, T1, T2, T3, T4, T5), Error>

impl<T0, T1, T2, T3, T4, T5, T6> Decode for (T0, T1, T2, T3, T4, T5, T6)

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode, T5: Decode, T6: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), Error>

fn decode( reader: &mut impl Decoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7> Decode for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode, T5: Decode, T6: Decode, T7: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), Error>

fn decode( reader: &mut impl Decoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), Error>

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

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode, T5: Decode, T6: Decode, T7: Decode, T8: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), Error>

fn decode( reader: &mut impl Decoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), Error>

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

where T0: Decode, T1: Decode, T2: Decode, T3: Decode, T4: Decode, T5: Decode, T6: Decode, T7: Decode, T8: Decode, T9: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), Error>

fn decode( reader: &mut impl Decoder, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), Error>

impl<T> Decode for Option<T>

where T: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<Option<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<Option<T>, Error>

impl<T> Decode for Box<[T]>

where T: Decode,

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Box<[T]>, Error>

fn decode(reader: &mut impl Decoder) -> Result<Box<[T]>, Error>

impl<T> Decode for Box<T>

where T: Decode,

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Box<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<Box<T>, Error>

impl<T> Decode for BinaryHeap<T>

where T: Decode + Ord,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<BinaryHeap<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<BinaryHeap<T>, Error>

impl<T> Decode for LinkedList<T>

where T: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<LinkedList<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<LinkedList<T>, Error>

impl<T> Decode for VecDeque<T>

where T: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<VecDeque<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<VecDeque<T>, Error>

impl<T> Decode for Vec<T>

where T: Decode,

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<Vec<T>, Error>

fn decode(reader: &mut impl Decoder) -> Result<Vec<T>, Error>

impl<T> Decode for PhantomData<T>

async fn decode_async( _: &mut impl AsyncDecoder, ) -> Result<PhantomData<T>, Error>

fn decode(_: &mut impl Decoder) -> Result<PhantomData<T>, Error>

impl<T, E> Decode for Result<T, E>

where T: Decode, E: Decode,

async fn decode_async( reader: &mut impl AsyncDecoder, ) -> Result<Result<T, E>, Error>

fn decode(reader: &mut impl Decoder) -> Result<Result<T, E>, Error>

impl<T, const N: usize> Decode for [T; N]

where T: Decode,

async fn decode_async(reader: &mut impl AsyncDecoder) -> Result<[T; N], Error>

fn decode(reader: &mut impl Decoder) -> Result<[T; N], Error>

Implementors

impl Decode for Error

impl Decode for BitVector

impl Decode for BloomFilter

impl Decode for Encypted

impl Decode for Key

impl Decode for Digest

impl Decode for PublicKey

impl Decode for Signature

impl<T> Decode for SignedValue<T>

where T: Decode,