Trait TopDecode

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 { ... }
}

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

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

where I: TopDecodeInput,

Attempt to deserialize the value from input.

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.

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 TopDecode for BigInt

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

where I: TopDecodeInput, H: DecodeErrorHandler,

impl TopDecode for BigUint

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<BigUint, <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,

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

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

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,

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

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode, T10: NestedDecode, T11: NestedDecode,

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,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode, T10: NestedDecode, T11: NestedDecode, T12: NestedDecode,

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,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode, T10: NestedDecode, T11: NestedDecode, T12: NestedDecode, T13: NestedDecode,

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,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode, T10: NestedDecode, T11: NestedDecode, T12: NestedDecode, T13: NestedDecode, T14: NestedDecode,

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,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode, T7: NestedDecode, T8: NestedDecode, T9: NestedDecode, T10: NestedDecode, T11: NestedDecode, T12: NestedDecode, T13: NestedDecode, T14: NestedDecode, T15: NestedDecode,

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 Box<str>

impl TopDecode for BoxedBytes

impl TopDecode for H256

impl TopDecode for String

impl TopDecode for CodeMetadata

impl TopDecode for Empty

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

where E: ErrorApi,

impl<M> TopDecode for ManagedAddress<M>

where M: ManagedTypeApi,

impl<M> TopDecode for ManagedArgBuffer<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 N: usize> TopDecode for ManagedByteArray<M, N>

where M: ManagedTypeApi,

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

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

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

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

impl<M: ManagedTypeApi> TopDecode for multiversx_sc::types::BigInt<M>

impl<M: ManagedTypeApi> TopDecode for multiversx_sc::types::BigUint<M>

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

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

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

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

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

impl<M: ManagedTypeApi> TopDecode for ManagedDecimal<M, NumDecimals>

impl<M: ManagedTypeApi> TopDecode for ManagedDecimalSigned<M, NumDecimals>

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

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

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

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

where T: NestedDecode,

impl<T> TopDecode for Box<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,

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

Deserializes like a Vec.

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

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

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