Enum pallet_utility::Call

pub enum Call<T: Trait> {
    batch(Vec<<T as Trait>::Call>),
    as_sub(u16, Box<<T as Trait>::Call>),
    as_limited_sub(u16, Box<<T as Trait>::Call>),
    // some variants omitted
}

Dispatchable calls.

Each variant of this enum maps to a dispatchable function from the associated module.

Variants

batch(Vec<<T as Trait>::Call>)

Send a batch of dispatch calls.

This will execute until the first one fails and then stop. Calls must fulfil the IsCallable filter unless the origin is Root.

May be called from any origin.

• calls: The calls to be dispatched from the same origin.

• Base weight: 14.39 + .987 * c µs
• Plus the sum of the weights of the calls.
• Plus one additional event. (repeat read/write)

This will return Ok in all circumstances. To determine the success of the batch, an event is deposited. If a call failed and the batch was interrupted, then the BatchInterrupted event is deposited, along with the number of successful calls made and the error of the failed call. If all were successful, then the BatchCompleted event is deposited.

as_sub(u16, Box<<T as Trait>::Call>)

Send a call through an indexed pseudonym of the sender.

The call must fulfil only the pre-cleared IsCallable filter (i.e. only the level of filtering that remains after calling take()).

NOTE: If you need to ensure that any account-based filtering is honored (i.e. because you expect proxy to have been used prior in the call stack and you want it to apply to any sub-accounts), then use as_limited_sub instead.

The dispatch origin for this call must be Signed.

• Base weight: 2.861 µs
• Plus the weight of the call

as_limited_sub(u16, Box<<T as Trait>::Call>)

Send a call through an indexed pseudonym of the sender.

Calls must each fulfil the IsCallable filter; it is not cleared before.

NOTE: If you need to ensure that any account-based filtering is not honored (i.e. because you expect proxy to have been used prior in the call stack and you do not want the call restrictions to apply to any sub-accounts), then use as_sub instead.

The dispatch origin for this call must be Signed.

• Base weight: 2.861 µs
• Plus the weight of the call

Trait Implementations

impl<T: Trait> Clone for Call<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Trait> Debug for Call<T>

fn fmt(&self, _f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<T: Trait> Decode for Call<T> where
    Vec<<T as Trait>::Call>: Decode,
    Vec<<T as Trait>::Call>: Decode,
    Box<<T as Trait>::Call>: Decode,
    Box<<T as Trait>::Call>: Decode,
    Box<<T as Trait>::Call>: Decode,
    Box<<T as Trait>::Call>: Decode, 

fn decode<DecIn: Input>(input: &mut DecIn) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl<T: Trait> Dispatchable for Call<T>

type Trait = T

...

type Origin = T::Origin

Every function call from your runtime has an origin, which specifies where the extrinsic was generated from. In the case of a signed extrinsic (transaction), the origin contains an identifier for the caller. The origin can be empty in the case of an inherent extrinsic.

type Info = DispatchInfo

An opaque set of information attached to the transaction. This could be constructed anywhere down the line in a runtime. The current Substrate runtime uses a struct with the same name to represent the dispatch class and weight.

type PostInfo = PostDispatchInfo

Additional information that is returned by dispatch. Can be used to supply the caller with information about a Dispatchable that is ownly known post dispatch.

fn dispatch(self, _origin: Self::Origin) -> DispatchResultWithPostInfo

Actually dispatch this call and return the result of it.

impl<T: Trait> Encode for Call<T> where
    Vec<<T as Trait>::Call>: Encode,
    Vec<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode, 

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

impl<T: Trait> EncodeLike<Call<T>> for Call<T> where
    Vec<<T as Trait>::Call>: Encode,
    Vec<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode,
    Box<<T as Trait>::Call>: Encode, 

impl<T: Trait> Eq for Call<T>

impl<T: Trait> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names.

impl<T: Trait> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Trait> PartialEq<Call<T>> for Call<T>

fn eq(&self, _other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.