Trait libipld::prelude::Decode

pub trait Decode<C>: Sized
where
    C: Codec,
{
    // Required method
    fn decode<R>(c: C, r: &mut R) -> Result<Self, Error>
       where R: Read + Seek;
}

Decode trait.

This trait is generic over a codec, so that different codecs can be implemented for the same type.

Required Methods

fn decode<R>(c: C, r: &mut R) -> Result<Self, Error>

where R: Read + Seek,

Decode from an impl Read.

It takes a specific codec as parameter, so that the Decode can be generic over an enum that contains multiple codecs.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Decode<DagCborCodec> for bool

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<bool, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for f32

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<f32, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for f64

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<f64, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for i8

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<i8, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for i16

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<i16, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for i32

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<i32, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for i64

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<i64, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for i128

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<i128, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for u8

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<u8, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for u16

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<u16, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for u32

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<u32, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for u64

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<u64, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for u128

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<u128, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for ()

fn decode<R>(_c: DagCborCodec, r: &mut R) -> Result<(), Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for Box<[u8]>

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<Box<[u8]>, Error>

where R: Read + Seek,

impl Decode<DagCborCodec> for String

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<String, Error>

where R: Read + Seek,

impl Decode<RawCodec> for Box<[u8]>

fn decode<R>(c: RawCodec, r: &mut R) -> Result<Box<[u8]>, Error>

where R: Read + Seek,

impl Decode<RawCodec> for Vec<u8>

fn decode<R>(_: RawCodec, r: &mut R) -> Result<Vec<u8>, Error>

where R: Read + Seek,

impl<A> Decode<DagCborCodec> for (A,)

where A: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<(A,), Error>

where R: Read + Seek,

impl<A, B> Decode<DagCborCodec> for (A, B)

where A: Decode<DagCborCodec>, B: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<(A, B), Error>

where R: Read + Seek,

impl<A, B, C> Decode<DagCborCodec> for (A, B, C)

where A: Decode<DagCborCodec>, B: Decode<DagCborCodec>, C: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<(A, B, C), Error>

where R: Read + Seek,

impl<A, B, C, D> Decode<DagCborCodec> for (A, B, C, D)

where A: Decode<DagCborCodec>, B: Decode<DagCborCodec>, C: Decode<DagCborCodec>, D: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<(A, B, C, D), Error>

where R: Read + Seek,

impl<K, T> Decode<DagCborCodec> for BTreeMap<K, T>

where K: Decode<DagCborCodec> + Ord, T: Decode<DagCborCodec>,

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<BTreeMap<K, T>, Error>

where R: Read + Seek,

impl<T> Decode<DagCborCodec> for Option<T>

where T: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<Option<T>, Error>

where R: Read + Seek,

impl<T> Decode<DagCborCodec> for Arc<T>

where T: Decode<DagCborCodec>,

fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<Arc<T>, Error>

where R: Read + Seek,

impl<T> Decode<DagCborCodec> for Vec<T>

where T: Decode<DagCborCodec>,

fn decode<R>(_: DagCborCodec, r: &mut R) -> Result<Vec<T>, Error>

where R: Read + Seek,

Implementors

impl Decode<IpldCodec> for Ipld

impl Decode<DagCborCodec> for Ipld

impl Decode<DagCborCodec> for Cid<64>

impl Decode<DagJsonCodec> for Ipld

impl Decode<RawCodec> for Ipld

impl<C> Decode<C> for IgnoredAny

where C: Codec + SkipOne,

impl<C> Decode<C> for RawValue<C>

where C: Codec + SkipOne,

impl<C, T> Decode<C> for Link<T>

where C: Codec, Cid<64>: Decode<C>,