Trait NestedDecode

pub trait NestedDecode: Sized {
    // Provided methods
    fn dep_decode<I>(input: &mut I) -> Result<Self, DecodeError>
       where I: NestedDecodeInput { ... }
    fn dep_decode_or_handle_err<I, H>(
        input: &mut I,
        h: H,
    ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>
       where I: NestedDecodeInput,
             H: DecodeErrorHandler { ... }
}

Trait that allows zero-copy read of value-references from slices in LE format.

Provided Methods

fn dep_decode<I>(input: &mut I) -> Result<Self, DecodeError>

where I: NestedDecodeInput,

Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation.

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

Version of dep_decode that can handle errors as soon as they occur. For instance in 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 NestedDecode for bool

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<bool, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for i8

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<i8, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for i16

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<i16, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for i32

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<i32, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for i64

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<i64, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for isize

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<isize, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for u8

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<u8, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for u16

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<u16, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for u32

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<u32, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for u64

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<u64, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for ()

fn dep_decode_or_handle_err<I, H>( _input: &mut I, _h: H, ) -> Result<(), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for usize

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<usize, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for NonZero<usize>

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<NonZero<usize>, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for HeapAddress

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<HeapAddress, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl NestedDecode for HeapH256

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<HeapH256, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0> NestedDecode for (T0,)

where T0: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0,), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1> NestedDecode for (T0, T1)

where T0: NestedDecode, T1: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2> NestedDecode for (T0, T1, T2)

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

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

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

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

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

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

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

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

where T0: NestedDecode, T1: NestedDecode, T2: NestedDecode, T3: NestedDecode, T4: NestedDecode, T5: NestedDecode, T6: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut 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: NestedDecodeInput, H: DecodeErrorHandler,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> NestedDecode 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 dep_decode_or_handle_err<I, H>( input: &mut 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: NestedDecodeInput, H: DecodeErrorHandler,

impl<T> NestedDecode for Option<T>

where T: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Option<T>, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

impl<T> NestedDecode for PhantomData<T>

fn dep_decode_or_handle_err<I, H>( _input: &mut I, _h: H, ) -> Result<PhantomData<T>, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

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

where T: NestedDecode,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<[T; N], <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

Implementors

impl NestedDecode for EsdtLocalRole

impl NestedDecode for EsdtTokenType

impl NestedDecode for MessageHashType

impl NestedDecode for Sign

impl NestedDecode for Address

impl NestedDecode for Bech32Address

impl NestedDecode for Box<str>

impl NestedDecode for BoxedBytes

impl NestedDecode for CodeMetadata

impl NestedDecode for Empty

impl NestedDecode for H256

impl NestedDecode for multiversx_sc_scenario::imports::RustBigInt

impl NestedDecode for multiversx_sc_scenario::imports::RustBigUint

impl NestedDecode for String

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

where E: ErrorApi,

impl<M> NestedDecode for EgldOrMultiEsdtPayment<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for BigFloat<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for multiversx_sc_scenario::imports::BigInt<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for multiversx_sc_scenario::imports::BigUint<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for EgldOrEsdtTokenIdentifier<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for EgldOrEsdtTokenPayment<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for EsdtTokenData<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for EsdtTokenPayment<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedAddress<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedArgBuffer<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedBuffer<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedBufferReadToEnd<M>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedDecimal<M, usize>

where M: ManagedTypeApi,

impl<M> NestedDecode for ManagedDecimalSigned<M, usize>

where M: ManagedTypeApi,

impl<M> NestedDecode for TokenIdentifier<M>

where M: ManagedTypeApi,

impl<M, T> NestedDecode for ManagedOption<M, T>

where M: ManagedTypeApi, T: ManagedType<M> + NestedDecode,

impl<M, T> NestedDecode for ManagedVec<M, T>

where M: ManagedTypeApi, T: ManagedVecItem + NestedDecode,

impl<M, const DECIMALS: usize> NestedDecode for ManagedDecimal<M, ConstDecimals<DECIMALS>>

where M: ManagedTypeApi,

impl<M, const DECIMALS: usize> NestedDecode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

where M: ManagedTypeApi,

impl<M, const N: usize> NestedDecode for ManagedByteArray<M, N>

where M: ManagedTypeApi,

impl<T> NestedDecode for Box<T>

where T: NestedDecode,

impl<T> NestedDecode for LinkedListNode<T>

where T: NestedEncode + NestedDecode + TopEncode + TopDecode + Clone,

impl<T> NestedDecode for Queue<T>

where T: NestedDecode,

Deserializes like a Vec.

impl<T> NestedDecode for Vec<T>

where T: NestedDecode,

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

where T: NestedDecode,