Trait TopDecode

Source

pub trait TopDecode: Sized {
    // Provided methods
    fn top_decode<I>(input: I) -> Result<Self, DecodeError>
       where I: TopDecodeInput { ... }
    fn top_decode_or_handle_err<I, H>(
        input: I,
        h: H,
    ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>
       where I: TopDecodeInput,
             H: DecodeErrorHandler { ... }
}

Expand description

Trait that allows zero-copy read of values from an underlying API in big endian format.

‘Top’ stands for the fact that values are deserialized on their own, so we have the benefit of knowing their length. This is useful in many scnearios, such as not having to encode Vec length and others.

The opther optimization that can be done when deserializing top-level objects is using special functions from the underlying API that do some of the work for the deserializer. These include getting values directly as i64/u64 or wrapping them directly into an owned Box<u8>.

BigInt/BigUint handling is not included here, because these are API-dependent and would overly complicate the trait.

Provided Methods§

Source

fn top_decode<I>(input: I) -> Result<Self, DecodeError>
where I: TopDecodeInput,

Attempt to deserialize the value from input.

Source

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

Version of top_decode that can handle errors as soon as they occur. For instance it can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

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.

Trait TopDecodeCopy item path

Provided Methods§

fn top_decode<I>(input: I) -> Result<Self, DecodeError>where I: TopDecodeInput,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

Dyn Compatibility§

Implementations on Foreign Types§

impl TopDecode for bool

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<bool, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for i8

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i8, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for i16

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i16, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for i32

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i32, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for i64

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i64, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for isize

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<isize, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for u8

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u8, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for u16

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u16, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for u32

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u32, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for u64

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u64, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for usize

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<usize, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for NonZero<usize>

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<NonZero<usize>, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for HeapAddress

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<HeapAddress, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for HeapH256

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<HeapH256, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0> TopDecode for (T0,)where T0: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0,), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1> TopDecode for (T0, T1)where T0: NestedDecode, T1: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2> TopDecode for (T0, T1, T2)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3> TopDecode for (T0, T1, T2, T3)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4> TopDecode for (T0, T1, T2, T3, T4)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5> TopDecode for (T0, T1, T2, T3, T4, T5)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6> TopDecode for (T0, T1, T2, T3, T4, T5, T6)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T> TopDecode for Option<T>where T: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Option<T>, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T> TopDecode for PhantomData<T>

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<PhantomData<T>, <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T, const N: usize> TopDecode for [T; N]where T: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<[T; N], <H as DecodeErrorHandler>::HandledErr>where I: TopDecodeInput, H: DecodeErrorHandler,

Implementors§

impl TopDecode for EsdtLocalRole

impl TopDecode for EsdtTokenType

impl TopDecode for MessageHashType

impl TopDecode for OperationCompletionStatus

impl TopDecode for Sign

impl TopDecode for Address

impl TopDecode for Bech32Address

impl TopDecode for Box<str>

impl TopDecode for BoxedBytes

impl TopDecode for CodeMetadata

impl TopDecode for Empty

impl TopDecode for H256

impl TopDecode for multiversx_sc_snippets::imports::RustBigInt

Trait TopDecode

fn top_decode<I>(input: I) -> Result<Self, DecodeError>
where I: TopDecodeInput,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<bool, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i8, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i16, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i32, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<i64, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<isize, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u8, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u16, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u32, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<u64, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<usize, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<NonZero<usize>, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<HeapAddress, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<HeapH256, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0> TopDecode for (T0,)
where T0: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0,), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1> TopDecode for (T0, T1)
where T0: NestedDecode, T1: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2> TopDecode for (T0, T1, T2)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3> TopDecode for (T0, T1, T2, T3)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4> TopDecode for (T0, T1, T2, T3, T4)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5> TopDecode for (T0, T1, T2, T3, T4, T5)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6> TopDecode for (T0, T1, T2, T3, T4, T5, T6)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T> TopDecode for Option<T>
where T: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Option<T>, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<PhantomData<T>, <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<T, const N: usize> TopDecode for [T; N]
where T: NestedDecode,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<[T; N], <H as DecodeErrorHandler>::HandledErr>
where I: TopDecodeInput, H: DecodeErrorHandler,

impl<E, const CAPACITY: usize> TopDecode for SparseArray<E, CAPACITY>
where E: ErrorApi,

impl<M> TopDecode for EgldOrMultiEsdtPayment<M>
where M: ManagedTypeApi,

impl<M> TopDecode for TokenMapperState<M>
where M: ManagedTypeApi,

impl<M> TopDecode for BigFloat<M>
where M: ManagedTypeApi,

impl<M> TopDecode for multiversx_sc_snippets::imports::BigInt<M>
where M: ManagedTypeApi,

impl<M> TopDecode for multiversx_sc_snippets::imports::BigUint<M>
where M: ManagedTypeApi,

impl<M> TopDecode for CallbackClosureForDeser<M>
where M: ManagedTypeApi + ErrorApi,

impl<M> TopDecode for EgldOrEsdtTokenIdentifier<M>
where M: ManagedTypeApi,

impl<M> TopDecode for EgldOrEsdtTokenPayment<M>
where M: ManagedTypeApi,

impl<M> TopDecode for EsdtTokenData<M>
where M: ManagedTypeApi,

impl<M> TopDecode for EsdtTokenPayment<M>
where M: ManagedTypeApi,

impl<M> TopDecode for ManagedAddress<M>
where M: ManagedTypeApi,

impl<M> TopDecode for ManagedArgBuffer<M>
where M: ManagedTypeApi,

impl<M> TopDecode for ManagedBuffer<M>
where M: ManagedTypeApi,

impl<M> TopDecode for ManagedDecimal<M, usize>
where M: ManagedTypeApi,

impl<M> TopDecode for ManagedDecimalSigned<M, usize>
where M: ManagedTypeApi,

impl<M> TopDecode for TokenIdentifier<M>
where M: ManagedTypeApi,

impl<M, T> TopDecode for ManagedOption<M, T>
where M: ManagedTypeApi, T: ManagedType<M> + NestedDecode,

impl<M, T> TopDecode for ManagedVec<M, T>
where M: ManagedTypeApi, T: ManagedVecItem + NestedDecode,

impl<M, const DECIMALS: usize> TopDecode for ManagedDecimal<M, ConstDecimals<DECIMALS>>
where M: ManagedTypeApi,

impl<M, const DECIMALS: usize> TopDecode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>
where M: ManagedTypeApi,

impl<M, const N: usize> TopDecode for ManagedByteArray<M, N>
where M: ManagedTypeApi,

impl<T> TopDecode for Box<[T]>
where T: NestedDecode,

impl<T> TopDecode for Box<T>
where T: TopDecode,

impl<T> TopDecode for LinkedListNode<T>
where T: NestedEncode + NestedDecode + TopEncode + TopDecode + Clone,

impl<T> TopDecode for OrderedBinaryTreeNode<T>
where T: NestedEncode + NestedDecode + PartialOrd + PartialEq + Clone,

impl<T> TopDecode for Queue<T>
where T: NestedDecode,

impl<T> TopDecode for SingleValue<T>
where T: TopDecode,

impl<T> TopDecode for Vec<T>
where T: NestedDecode,

impl<T, const CAP: usize> TopDecode for ArrayVec<T, CAP>
where T: NestedDecode,