Trait libipld::codec::Decode

pub trait Decode<C> where
    C: Codec, {
    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.

Implementations on Foreign Types

impl Decode<DagCborCodec> for bool

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<bool, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for u8

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<u8, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for f32

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<f32, Error> where
    R: Read + Seek, 

impl<T> Decode<DagCborCodec> for Option<T> where
    T: Decode<DagCborCodec>, 

pub fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<Option<T>, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for i16

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<i16, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for u64

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<u64, Error> where
    R: Read + Seek, 

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

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

impl Decode<DagCborCodec> for i64

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<i64, Error> where
    R: Read + Seek, 

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

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<Box<[u8], Global>, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for ()

pub fn decode<R>(_c: DagCborCodec, r: &mut R) -> Result<(), Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for String

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<String, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for i8

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<i8, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for u32

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<u32, Error> where
    R: Read + Seek, 

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

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

impl<T> Decode<DagCborCodec> for Vec<T, Global> where
    T: Decode<DagCborCodec>, 

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<Vec<T, Global>, Error> where
    R: Read + Seek, 

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

pub 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>, 

pub fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<(A, B), Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for f64

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<f64, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for u16

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<u16, Error> where
    R: Read + Seek, 

impl<T> Decode<DagCborCodec> for Arc<T> where
    T: Decode<DagCborCodec>, 

pub fn decode<R>(c: DagCborCodec, r: &mut R) -> Result<Arc<T>, Error> where
    R: Read + Seek, 

impl<K, T> Decode<DagCborCodec> for BTreeMap<K, T> where
    T: Decode<DagCborCodec>,
    K: Decode<DagCborCodec> + Ord, 

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<BTreeMap<K, T>, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for i32

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<i32, Error> where
    R: Read + Seek, 

impl Decode<RawCodec> for Vec<u8, Global>

pub fn decode<R>(RawCodec, r: &mut R) -> Result<Vec<u8, Global>, Error> where
    R: Read + Seek, 

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

pub fn decode<R>(c: RawCodec, r: &mut R) -> Result<Box<[u8], Global>, Error> where
    R: Read + Seek, 

Implementors

impl Decode<IpldCodec> for Ipld

fn decode<R: Read + Seek>(c: IpldCodec, r: &mut R) -> Result<Self>

impl Decode<RawCodec> for Ipld

pub fn decode<R>(c: RawCodec, r: &mut R) -> Result<Ipld, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for Ipld

pub fn decode<R>(DagCborCodec, r: &mut R) -> Result<Ipld, Error> where
    R: Read + Seek, 

impl Decode<DagCborCodec> for Cid<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>

pub fn decode<R>(
    DagCborCodec,
    r: &mut R
) -> Result<Cid<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>, Error> where
    R: Read + Seek, 

impl Decode<DagJsonCodec> for Ipld

pub fn decode<R>(DagJsonCodec, r: &mut R) -> Result<Ipld, Error> where
    R: Read + Seek, 

impl Decode<DagPbCodec> for Ipld

pub fn decode<R>(DagPbCodec, r: &mut R) -> Result<Ipld, Error> where
    R: Read + Seek, 

impl<C> Decode<C> for IgnoredAny where
    C: Codec + SkipOne, 

pub fn decode<R>(c: C, r: &mut R) -> Result<IgnoredAny, Error> where
    R: Read + Seek, 

impl<C> Decode<C> for RawValue<C> where
    C: Codec + SkipOne, 

pub fn decode<R>(c: C, r: &mut R) -> Result<RawValue<C>, Error> where
    R: Read + Seek, 

impl<C, T> Decode<C> for Link<T> where
    C: Codec,
    Cid<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>: Decode<C>, 

pub fn decode<R>(c: C, r: &mut R) -> Result<Link<T>, Error> where
    R: Read + Seek,