Trait Decode 

pub trait Decode<'b, C>: Sized {
    // Required method
    fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Self, Error>;

    // Provided method
    fn nil() -> Option<Self> { ... }
}

A type that can be decoded from CBOR.

Required Methods

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Self, Error>

Decode a value using the given Decoder.

In addition to the decoder a user provided decoding context is given as another parameter. Most implementations of this trait do not need a decoding context and should be completely generic in the context type. In cases where a context is needed and the Decode impl type is meant to be combined with other types that require a different context type, it is preferrable to constrain the context type variable C with a trait bound instead of fixing the type.

Provided Methods

fn nil() -> Option<Self>

If possible, return a nil value of Self.

This method is primarily used by minicbor-derive and allows creating a special value denoting the absence of a “real” value if no CBOR value is present. The canonical example of a type where this is sensible is the Option type, whose Decode::nil method would return Some(None).

With the exception of Option<_> all types T are considered mandatory by default, i.e. T::nil() returns None. Missing values of T therefore cause decoding errors in derived Decode implementations.

NB: A type implementing Decode with an overriden Decode::nil method should also override Encode::is_nil if it implements Encode at all.

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<'a, 'b, C> Decode<'b, C> for &'a str

where 'b: 'a,

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<&'a str, Error>

impl<'a, 'b, C> Decode<'b, C> for &'a CStr

where 'b: 'a,

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<&'a CStr, Error>

impl<'a, 'b, C> Decode<'b, C> for &'a Path

where 'b: 'a,

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<&'a Path, Error>

impl<'a, C, const BYTES: usize> Decode<'a, C> for Hash<BYTES>

fn decode(d: &mut Decoder<'a>, _ctx: &mut C) -> Result<Hash<BYTES>, Error>

impl<'b, C> Decode<'b, C> for IpAddr

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<IpAddr, Error>

impl<'b, C> Decode<'b, C> for SocketAddr

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SocketAddr, Error>

impl<'b, C> Decode<'b, C> for bool

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<bool, Error>

impl<'b, C> Decode<'b, C> for char

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<char, Error>

impl<'b, C> Decode<'b, C> for f32

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<f32, Error>

impl<'b, C> Decode<'b, C> for f64

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<f64, Error>

impl<'b, C> Decode<'b, C> for i8

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<i8, Error>

impl<'b, C> Decode<'b, C> for i16

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<i16, Error>

impl<'b, C> Decode<'b, C> for i32

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<i32, Error>

impl<'b, C> Decode<'b, C> for i64

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<i64, Error>

impl<'b, C> Decode<'b, C> for isize

Available on 64-bit only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<isize, Error>

impl<'b, C> Decode<'b, C> for u8

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<u8, Error>

impl<'b, C> Decode<'b, C> for u16

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<u16, Error>

impl<'b, C> Decode<'b, C> for u32

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<u32, Error>

impl<'b, C> Decode<'b, C> for u64

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<u64, Error>

impl<'b, C> Decode<'b, C> for ()

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<(), Error>

impl<'b, C> Decode<'b, C> for usize

Available on 64-bit only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<usize, Error>

impl<'b, C> Decode<'b, C> for Box<str>

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<Box<str>, Error>

impl<'b, C> Decode<'b, C> for Box<Path>

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Box<Path>, Error>

impl<'b, C> Decode<'b, C> for CString

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<CString, Error>

impl<'b, C> Decode<'b, C> for String

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<String, Error>

impl<'b, C> Decode<'b, C> for Ipv4Addr

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Ipv4Addr, Error>

impl<'b, C> Decode<'b, C> for Ipv6Addr

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Ipv6Addr, Error>

impl<'b, C> Decode<'b, C> for SocketAddrV4

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SocketAddrV4, Error>

impl<'b, C> Decode<'b, C> for SocketAddrV6

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SocketAddrV6, Error>

impl<'b, C> Decode<'b, C> for NonZero<i8>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<i8>, Error>

impl<'b, C> Decode<'b, C> for NonZero<i16>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<i16>, Error>

impl<'b, C> Decode<'b, C> for NonZero<i32>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<i32>, Error>

impl<'b, C> Decode<'b, C> for NonZero<i64>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<i64>, Error>

impl<'b, C> Decode<'b, C> for NonZero<isize>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<isize>, Error>

impl<'b, C> Decode<'b, C> for NonZero<u8>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<u8>, Error>

impl<'b, C> Decode<'b, C> for NonZero<u16>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<u16>, Error>

impl<'b, C> Decode<'b, C> for NonZero<u32>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<u32>, Error>

impl<'b, C> Decode<'b, C> for NonZero<u64>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<u64>, Error>

impl<'b, C> Decode<'b, C> for NonZero<usize>

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZero<usize>, Error>

impl<'b, C> Decode<'b, C> for AtomicBool

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicBool, Error>

impl<'b, C> Decode<'b, C> for AtomicI8

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicI8, Error>

impl<'b, C> Decode<'b, C> for AtomicI16

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicI16, Error>

impl<'b, C> Decode<'b, C> for AtomicI32

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicI32, Error>

impl<'b, C> Decode<'b, C> for AtomicI64

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicI64, Error>

impl<'b, C> Decode<'b, C> for AtomicIsize

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicIsize, Error>

impl<'b, C> Decode<'b, C> for AtomicU8

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicU8, Error>

impl<'b, C> Decode<'b, C> for AtomicU16

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicU16, Error>

impl<'b, C> Decode<'b, C> for AtomicU32

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicU32, Error>

impl<'b, C> Decode<'b, C> for AtomicU64

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicU64, Error>

impl<'b, C> Decode<'b, C> for AtomicUsize

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AtomicUsize, Error>

impl<'b, C> Decode<'b, C> for Duration

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Duration, Error>

impl<'b, C> Decode<'b, C> for PathBuf

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<PathBuf, Error>

impl<'b, C> Decode<'b, C> for SystemTime

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SystemTime, Error>

impl<'b, C> Decode<'b, C> for AddrAttrProperty

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AddrAttrProperty, Error>

impl<'b, C> Decode<'b, C> for AddrDistr

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AddrDistr, Error>

impl<'b, C> Decode<'b, C> for AddrType

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<AddrType, Error>

impl<'b, C> Decode<'b, C> for Anchor

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Anchor, Error>

impl<'b, C> Decode<'b, C> for AnyCbor

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<AnyCbor, Error>

impl<'b, C> Decode<'b, C> for AnyUInt

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<AnyUInt, Error>

impl<'b, C> Decode<'b, C> for AuxiliaryData

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<AuxiliaryData, Error>

impl<'b, C> Decode<'b, C> for BigInt

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<BigInt, Error>

impl<'b, C> Decode<'b, C> for BlockSig

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<BlockSig, Error>

impl<'b, C> Decode<'b, C> for BoundedBytes

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<BoundedBytes, Error>

impl<'b, C> Decode<'b, C> for Certificate

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Certificate, Error>

impl<'b, C> Decode<'b, C> for Certificate

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Certificate, Error>

impl<'b, C> Decode<'b, C> for Constitution

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Constitution, Error>

impl<'b, C> Decode<'b, C> for DRep

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<DRep, Error>

impl<'b, C> Decode<'b, C> for DRepVotingThresholds

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<DRepVotingThresholds, Error>

impl<'b, C> Decode<'b, C> for EmptyMap

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<EmptyMap, Error>

impl<'b, C> Decode<'b, C> for GovAction

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<GovAction, Error>

impl<'b, C> Decode<'b, C> for GovActionId

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<GovActionId, Error>

impl<'b, C> Decode<'b, C> for InstantaneousRewardSource

fn decode( d: &mut Decoder<'b>, _ctx: &mut C, ) -> Result<InstantaneousRewardSource, Error>

impl<'b, C> Decode<'b, C> for InstantaneousRewardTarget

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<InstantaneousRewardTarget, Error>

impl<'b, C> Decode<'b, C> for Metadatum

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Metadatum, Error>

impl<'b, C> Decode<'b, C> for NativeScript

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NativeScript, Error>

impl<'b, C> Decode<'b, C> for NonZeroInt

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonZeroInt, Error>

impl<'b, C> Decode<'b, C> for PlutusData

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<PlutusData, Error>

impl<'b, C> Decode<'b, C> for PoolVotingThresholds

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<PoolVotingThresholds, Error>

impl<'b, C> Decode<'b, C> for PositiveCoin

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<PositiveCoin, Error>

impl<'b, C> Decode<'b, C> for ProposalProcedure

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<ProposalProcedure, Error>

impl<'b, C> Decode<'b, C> for RationalNumber

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<RationalNumber, Error>

impl<'b, C> Decode<'b, C> for Redeemers

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Redeemers, Error>

impl<'b, C> Decode<'b, C> for Relay

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Relay, Error>

impl<'b, C> Decode<'b, C> for SpendingData

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SpendingData, Error>

impl<'b, C> Decode<'b, C> for Ssc

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Ssc, Error>

impl<'b, C> Decode<'b, C> for SscProof

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<SscProof, Error>

impl<'b, C> Decode<'b, C> for StakeCredential

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<StakeCredential, Error>

impl<'b, C> Decode<'b, C> for Twit

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Twit, Error>

impl<'b, C> Decode<'b, C> for TxFeePol

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<TxFeePol, Error>

impl<'b, C> Decode<'b, C> for TxIn

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<TxIn, Error>

impl<'b, C> Decode<'b, C> for Value

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Value, Error>

impl<'b, C> Decode<'b, C> for Value

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Value, Error>

impl<'b, C> Decode<'b, C> for Vote

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<Vote, Error>

impl<'b, C> Decode<'b, C> for Voter

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Voter, Error>

impl<'b, C> Decode<'b, C> for VotingProcedure

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<VotingProcedure, Error>

impl<'b, C, A> Decode<'b, C> for Constr<A>

where A: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Constr<A>, Error>

impl<'b, C, A> Decode<'b, C> for MaybeIndefArray<A>

where A: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<MaybeIndefArray<A>, Error>

impl<'b, C, I, const T: u64> Decode<'b, C> for TagWrap<I, T>

where I: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<TagWrap<I, T>, Error>

impl<'b, C, K, V> Decode<'b, C> for BTreeMap<K, V>

where K: Decode<'b, C> + Eq + Ord, V: Decode<'b, C>,

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<BTreeMap<K, V>, Error>

impl<'b, C, K, V> Decode<'b, C> for KeyValuePairs<K, V>

where K: Decode<'b, C> + Clone, V: Decode<'b, C> + Clone,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<KeyValuePairs<K, V>, Error>

impl<'b, C, K, V> Decode<'b, C> for NonEmptyKeyValuePairs<K, V>

where K: Decode<'b, C> + Clone, V: Decode<'b, C> + Clone,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<NonEmptyKeyValuePairs<K, V>, Error>

impl<'b, C, K, V, S> Decode<'b, C> for HashMap<K, V, S>

where K: Decode<'b, C> + Eq + Hash, V: Decode<'b, C>, S: BuildHasher + Default,

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<HashMap<K, V, S>, Error>

impl<'b, C, P> Decode<'b, C> for OrderPreservingProperties<P>

where P: Decode<'b, C>,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<OrderPreservingProperties<P>, Error>

impl<'b, C, T> Decode<'b, C> for Cow<'_, T>

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode<'b, C>,

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Cow<'_, T>, Error>

impl<'b, C, T> Decode<'b, C> for Bound<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Bound<T>, Error>

impl<'b, C, T> Decode<'b, C> for Option<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Option<T>, Error>

fn nil() -> Option<Option<T>>

impl<'b, C, T> Decode<'b, C> for Box<T>

where T: Decode<'b, C>,

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Box<T>, Error>

impl<'b, C, T> Decode<'b, C> for BinaryHeap<T>

where T: Decode<'b, C> + Ord,

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<BinaryHeap<T>, Error>

impl<'b, C, T> Decode<'b, C> for BTreeSet<T>

where T: Decode<'b, C> + Ord,

Available on crate feature alloc only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<BTreeSet<T>, Error>

impl<'b, C, T> Decode<'b, C> for LinkedList<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<LinkedList<T>, Error>

impl<'b, C, T> Decode<'b, C> for VecDeque<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<VecDeque<T>, Error>

impl<'b, C, T> Decode<'b, C> for Vec<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Vec<T>, Error>

impl<'b, C, T> Decode<'b, C> for Cell<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Cell<T>, Error>

impl<'b, C, T> Decode<'b, C> for RefCell<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<RefCell<T>, Error>

impl<'b, C, T> Decode<'b, C> for PhantomData<T>

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<PhantomData<T>, Error>

impl<'b, C, T> Decode<'b, C> for Wrapping<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Wrapping<T>, Error>

impl<'b, C, T> Decode<'b, C> for Range<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Range<T>, Error>

impl<'b, C, T> Decode<'b, C> for RangeFrom<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<RangeFrom<T>, Error>

impl<'b, C, T> Decode<'b, C> for RangeInclusive<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<RangeInclusive<T>, Error>

impl<'b, C, T> Decode<'b, C> for RangeTo<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<RangeTo<T>, Error>

impl<'b, C, T> Decode<'b, C> for RangeToInclusive<T>

where T: Decode<'b, C>,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<RangeToInclusive<T>, Error>

impl<'b, C, T> Decode<'b, C> for CborWrap<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<CborWrap<T>, Error>

impl<'b, C, T> Decode<'b, C> for NonEmptySet<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<NonEmptySet<T>, Error>

impl<'b, C, T> Decode<'b, C> for Nullable<T>

where T: Decode<'b, C> + Clone,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Nullable<T>, Error>

impl<'b, C, T> Decode<'b, C> for PseudoDatumOption<T>

where T: Decode<'b, C>,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<PseudoDatumOption<T>, Error>

impl<'b, C, T> Decode<'b, C> for PseudoScript<T>

where T: Decode<'b, ()>,

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<PseudoScript<T>, Error>

impl<'b, C, T> Decode<'b, C> for PseudoScript<T>

where T: Decode<'b, ()>,

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<PseudoScript<T>, Error>

impl<'b, C, T> Decode<'b, C> for PseudoTransactionOutput<T>

where T: Decode<'b, C>,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<PseudoTransactionOutput<T>, Error>

impl<'b, C, T> Decode<'b, C> for PseudoTransactionOutput<T>

where T: Decode<'b, C>,

fn decode( d: &mut Decoder<'b>, ctx: &mut C, ) -> Result<PseudoTransactionOutput<T>, Error>

impl<'b, C, T> Decode<'b, C> for Set<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Set<T>, Error>

impl<'b, C, T> Decode<'b, C> for ZeroOrOneArray<T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<ZeroOrOneArray<T>, Error>

impl<'b, C, T, E> Decode<'b, C> for Result<T, E>

where T: Decode<'b, C>, E: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Result<T, E>, Error>

impl<'b, C, T, S> Decode<'b, C> for HashSet<T, S>

where T: Decode<'b, C> + Eq + Hash, S: BuildHasher + Default,

Available on crate feature std only.

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<HashSet<T, S>, Error>

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

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<[T; N], Error>

impl<'b, C, const N: usize> Decode<'b, C> for SkipCbor<N>

fn decode(d: &mut Decoder<'b>, _ctx: &mut C) -> Result<SkipCbor<N>, Error>

impl<'b, Ctx, A> Decode<'b, Ctx> for (A,)

where A: Decode<'b, Ctx>,

fn decode(d: &mut Decoder<'b>, ctx: &mut Ctx) -> Result<(A,), Error>

impl<'b, Ctx, A, B> Decode<'b, Ctx> for (A, B)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>,

fn decode(d: &mut Decoder<'b>, ctx: &mut Ctx) -> Result<(A, B), Error>

impl<'b, Ctx, A, B, C> Decode<'b, Ctx> for (A, B, C)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>,

fn decode(d: &mut Decoder<'b>, ctx: &mut Ctx) -> Result<(A, B, C), Error>

impl<'b, Ctx, A, B, C, D> Decode<'b, Ctx> for (A, B, C, D)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>,

fn decode(d: &mut Decoder<'b>, ctx: &mut Ctx) -> Result<(A, B, C, D), Error>

impl<'b, Ctx, A, B, C, D, E> Decode<'b, Ctx> for (A, B, C, D, E)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>,

fn decode(d: &mut Decoder<'b>, ctx: &mut Ctx) -> Result<(A, B, C, D, E), Error>

impl<'b, Ctx, A, B, C, D, E, F> Decode<'b, Ctx> for (A, B, C, D, E, F)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F), Error>

impl<'b, Ctx, A, B, C, D, E, F, G> Decode<'b, Ctx> for (A, B, C, D, E, F, G)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G), Error>

impl<'b, Ctx, A, B, C, D, E, F, G, H> Decode<'b, Ctx> for (A, B, C, D, E, F, G, H)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H), Error>

impl<'b, Ctx, A, B, C, D, E, F, G, H, I> Decode<'b, Ctx> for (A, B, C, D, E, F, G, H, I)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>, I: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I), Error>

impl<'b, Ctx, A, B, C, D, E, F, G, H, I, J> Decode<'b, Ctx> for (A, B, C, D, E, F, G, H, I, J)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>, I: Decode<'b, Ctx>, J: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J), Error>

impl<'b, Ctx, A, B, C, D, E, F, G, H, I, J, K> Decode<'b, Ctx> for (A, B, C, D, E, F, G, H, I, J, K)

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>, I: Decode<'b, Ctx>, J: Decode<'b, Ctx>, K: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Error>

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

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>, I: Decode<'b, Ctx>, J: Decode<'b, Ctx>, K: Decode<'b, Ctx>, L: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Error>

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

where A: Decode<'b, Ctx>, B: Decode<'b, Ctx>, C: Decode<'b, Ctx>, D: Decode<'b, Ctx>, E: Decode<'b, Ctx>, F: Decode<'b, Ctx>, G: Decode<'b, Ctx>, H: Decode<'b, Ctx>, I: Decode<'b, Ctx>, J: Decode<'b, Ctx>, K: Decode<'b, Ctx>, L: Decode<'b, Ctx>, M: Decode<'b, Ctx>,

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Error>

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

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

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Error>

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

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

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Error>

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

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

fn decode( d: &mut Decoder<'b>, ctx: &mut Ctx, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Error>

impl<'b, T, C> Decode<'b, C> for KeepRaw<'b, T>

where T: Decode<'b, C>,

fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<KeepRaw<'b, T>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedBlock<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedBlock<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedBlock<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedBlock<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedBlockBody<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedBlockBody<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedEbBlock<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedEbBlock<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedTx<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedTx<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedTxPayload<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedTxPayload<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedWitnessSet<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedWitnessSet<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedWitnessSet<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedWitnessSet<'b>, Error>

impl<'bytes, 'b, Ctx> Decode<'bytes, Ctx> for MintedWitnessSet<'b>

where 'bytes: 'b,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MintedWitnessSet<'b>, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Address

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Address, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for AddressPayload

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<AddressPayload, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BVerMod

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BVerMod, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Block

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Block, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Block

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Block, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BlockBody

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BlockBody, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BlockCons

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BlockCons, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BlockHead

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BlockHead, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BlockHeadEx

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BlockHeadEx, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BlockProof

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BlockProof, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for BootstrapWitness

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<BootstrapWitness, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ByronAddress

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ByronAddress, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Bytes

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Bytes, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for CostModels

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<CostModels, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for CostModels

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<CostModels, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Dlg

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Dlg, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for EbBlock

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<EbBlock, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for EbbCons

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<EbbCons, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for EbbHead

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<EbbHead, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ExUnitPrices

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ExUnitPrices, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ExUnitPrices

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ExUnitPrices, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ExUnits

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ExUnits, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for HeaderBody

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<HeaderBody, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for HeaderBody

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<HeaderBody, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Int

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Int, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Language

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Language, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Language

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Language, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Language

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Language, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Lwdlg

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Lwdlg, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for MoveInstantaneousReward

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<MoveInstantaneousReward, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for NetworkId

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<NetworkId, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Nonce

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Nonce, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for NonceVariant

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<NonceVariant, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for OperationalCert

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<OperationalCert, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for PoolMetadata

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PoolMetadata, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for PostAlonzoAuxiliaryData

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PostAlonzoAuxiliaryData, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for PostAlonzoAuxiliaryData

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PostAlonzoAuxiliaryData, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for PostAlonzoAuxiliaryData

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PostAlonzoAuxiliaryData, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ProtocolParamUpdate

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ProtocolParamUpdate, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ProtocolParamUpdate

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ProtocolParamUpdate, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ProtocolParamUpdate

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ProtocolParamUpdate, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Redeemer

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Redeemer, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Redeemer

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Redeemer, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for RedeemerPointer

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<RedeemerPointer, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for RedeemerTag

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<RedeemerTag, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for RedeemerTag

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<RedeemerTag, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for RedeemersKey

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<RedeemersKey, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for RedeemersValue

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<RedeemersValue, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ShelleyMaAuxiliaryData

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<ShelleyMaAuxiliaryData, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for SlotId

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<SlotId, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for TransactionBody

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<TransactionBody, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for TransactionInput

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<TransactionInput, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for TransactionOutput

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<TransactionOutput, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Tx

fn decode(__d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx) -> Result<Tx, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Tx

fn decode(__d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx) -> Result<Tx, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for TxOut

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<TxOut, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for TxPayload

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<TxPayload, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Up

fn decode(__d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx) -> Result<Up, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for UpProp

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<UpProp, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for UpVote

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<UpVote, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Update

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Update, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Update

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Update, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Update

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<Update, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for VKeyWitness

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<VKeyWitness, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for VrfCert

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<VrfCert, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for WitnessSet

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<WitnessSet, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for WitnessSet

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<WitnessSet, Error>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for WitnessSet

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<WitnessSet, Error>

impl<'bytes, Ctx, T1> Decode<'bytes, Ctx> for PseudoHeader<T1>

where T1: Decode<'bytes, Ctx>,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoHeader<T1>, Error>

impl<'bytes, Ctx, T1> Decode<'bytes, Ctx> for PseudoHeader<T1>

where T1: Decode<'bytes, Ctx>,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoHeader<T1>, Error>

impl<'bytes, Ctx, T1> Decode<'bytes, Ctx> for PseudoTransactionBody<T1>

where T1: Decode<'bytes, Ctx>,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoTransactionBody<T1>, Error>

impl<'bytes, Ctx, T1> Decode<'bytes, Ctx> for PseudoTransactionBody<T1>

where T1: Decode<'bytes, Ctx>,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoTransactionBody<T1>, Error>

impl<'bytes, Ctx, T1, T2, T3> Decode<'bytes, Ctx> for PseudoPostAlonzoTransactionOutput<T1, T2, T3>

where T1: Decode<'bytes, Ctx>, T2: Decode<'bytes, Ctx>, T3: Decode<'bytes, Ctx>,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoPostAlonzoTransactionOutput<T1, T2, T3>, Error>

impl<'bytes, Ctx, T1, T2, T3> Decode<'bytes, Ctx> for PseudoTx<T1, T2, T3>

where T1: Decode<'bytes, Ctx> + Clone, T2: Decode<'bytes, Ctx> + Clone, T3: Decode<'bytes, Ctx> + Clone,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoTx<T1, T2, T3>, Error>

impl<'bytes, Ctx, T1, T2, T3> Decode<'bytes, Ctx> for PseudoTx<T1, T2, T3>

where T1: Decode<'bytes, Ctx> + Clone, T2: Decode<'bytes, Ctx> + Clone, T3: Decode<'bytes, Ctx> + Clone,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoTx<T1, T2, T3>, Error>

impl<'bytes, Ctx, T1, T2, T3, T4> Decode<'bytes, Ctx> for PseudoBlock<T1, T2, T3, T4>

where T1: Decode<'bytes, Ctx>, T2: Decode<'bytes, Ctx>, T3: Decode<'bytes, Ctx>, T4: Decode<'bytes, Ctx> + Clone,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoBlock<T1, T2, T3, T4>, Error>

impl<'bytes, Ctx, T1, T2, T3, T4> Decode<'bytes, Ctx> for PseudoBlock<T1, T2, T3, T4>

where T1: Decode<'bytes, Ctx>, T2: Decode<'bytes, Ctx>, T3: Decode<'bytes, Ctx>, T4: Decode<'bytes, Ctx> + Clone,

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PseudoBlock<T1, T2, T3, T4>, Error>

impl<'bytes, Ctx, const VERSION: usize> Decode<'bytes, Ctx> for PlutusScript<VERSION>

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx, ) -> Result<PlutusScript<VERSION>, Error>

Implementors

impl<'a, 'b, C> Decode<'b, C> for &'a ByteSlice

where 'b: 'a,

impl<'b, C> Decode<'b, C> for Token<'b>

impl<'b, C> Decode<'b, C> for cardano_sdk::cbor::data::Int

impl<'b, C> Decode<'b, C> for Tag

impl<'b, C, const N: u64, T> Decode<'b, C> for Tagged<N, T>

where T: Decode<'b, C>,

impl<'b, C, const N: usize> Decode<'b, C> for ByteArray<N>

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Network

impl<'bytes, Ctx> Decode<'bytes, Ctx> for PlutusVersion

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Hash28

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Hash32

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Credential

impl<'bytes, Ctx> Decode<'bytes, Ctx> for ExecutionUnits

impl<'bytes, Ctx> Decode<'bytes, Ctx> for cardano_sdk::NetworkId

impl<'bytes, Ctx> Decode<'bytes, Ctx> for cardano_sdk::RedeemerPointer

impl<'bytes, Ctx, const SIZE: usize> Decode<'bytes, Ctx> for cardano_sdk::Hash<SIZE>

impl<'d, C> Decode<'d, C> for Input

impl<'d, C> Decode<'d, C> for Output

impl<'d, C> Decode<'d, C> for cardano_sdk::PlutusData<'static>

impl<'d, C> Decode<'d, C> for Transaction<ReadyForSigning>

impl<'d, C> Decode<'d, C> for Transaction<Unknown>

impl<'d, C> Decode<'d, C> for cardano_sdk::Value<u64>

impl<C> Decode<'_, C> for ByteVec

Available on crate feature alloc only.