Trait elrond_wasm::io::dyn_arg::DynArg

pub trait DynArg: Sized {
    fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self
    where
        I: TopDecodeInput,
        D: DynArgInput<I>;
}

Any type that is used as an endpoint argument must implement this trait.

Required methods

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

Implementors

impl<T0, T1> DynArg for MultiArg2<T0, T1> where
    T0: DynArg,
    T1: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2> DynArg for MultiArg3<T0, T1, T2> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3> DynArg for MultiArg4<T0, T1, T2, T3> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4> DynArg for MultiArg5<T0, T1, T2, T3, T4> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5> DynArg for MultiArg6<T0, T1, T2, T3, T4, T5> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6> DynArg for MultiArg7<T0, T1, T2, T3, T4, T5, T6> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7> DynArg for MultiArg8<T0, T1, T2, T3, T4, T5, T6, T7> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> DynArg for MultiArg9<T0, T1, T2, T3, T4, T5, T6, T7, T8> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> DynArg for MultiArg10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> DynArg for MultiArg11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> DynArg for MultiArg12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg,
    T11: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> DynArg for MultiArg13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg,
    T11: DynArg,
    T12: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> DynArg for MultiArg14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg,
    T11: DynArg,
    T12: DynArg,
    T13: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> DynArg for MultiArg15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg,
    T11: DynArg,
    T12: DynArg,
    T13: DynArg,
    T14: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> DynArg for MultiArg16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> where
    T0: DynArg,
    T1: DynArg,
    T2: DynArg,
    T3: DynArg,
    T4: DynArg,
    T5: DynArg,
    T6: DynArg,
    T7: DynArg,
    T8: DynArg,
    T9: DynArg,
    T10: DynArg,
    T11: DynArg,
    T12: DynArg,
    T13: DynArg,
    T14: DynArg,
    T15: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T> DynArg for AsyncCallResult<T> where
    T: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T> DynArg for OptionalArg<T> where
    T: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

impl<T> DynArg for MultiArgVec<T> where
    T: DynArg, 

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>, 

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

All top-deserializable types can be endpoint arguments.

fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> Self where
    I: TopDecodeInput,
    D: DynArgInput<I>,