Enum MultiVersion 

pub enum MultiVersion<A = InvalidVersion, B = InvalidVersion, C = InvalidVersion, D = InvalidVersion, E = InvalidVersion, F = InvalidVersion, G = InvalidVersion, H = InvalidVersion, I = InvalidVersion, J = InvalidVersion, K = InvalidVersion, L = InvalidVersion, M = InvalidVersion, N = InvalidVersion, O = InvalidVersion, P = InvalidVersion, Q = InvalidVersion, R = InvalidVersion, S = InvalidVersion, T = InvalidVersion, U = InvalidVersion, V = InvalidVersion, W = InvalidVersion, X = InvalidVersion, Y = InvalidVersion, Z = InvalidVersion> {
    A(A),
    B(B),
    C(C),
    D(D),
    E(E),
    F(F),
    G(G),
    H(H),
    I(I),
    J(J),
    K(K),
    L(L),
    M(M),
    N(N),
    O(O),
    P(P),
    Q(Q),
    R(R),
    S(S),
    T(T),
    U(U),
    V(V),
    W(W),
    X(X),
    Y(Y),
    Z(Z),
}

An implementation of Pipeline that aggregates multiple versioned transaction extension pipeline.

It is an enum where each variant has its own version, duplicated version must be avoided, only the first used version will be effective other duplicated version will be ignored.

Versioned transaction extension pipelines are configured using the generic parameters.

Example

use sp_runtime::traits::{MultiVersion, PipelineAtVers};

struct PaymentExt;
struct PaymentExtV2;
struct NonceExt;

type ExtV1 = PipelineAtVers<1, (NonceExt, PaymentExt)>;
type ExtV4 = PipelineAtVers<4, (NonceExt, PaymentExtV2)>;

/// The transaction extension pipeline that supports both version 1 and 4.
type TransactionExtension = MultiVersion<ExtV1, ExtV4>;

Variants

A(A)

The transaction extension pipeline of a specific version.

B(B)

The transaction extension pipeline of a specific version.

C(C)

The transaction extension pipeline of a specific version.

D(D)

The transaction extension pipeline of a specific version.

E(E)

The transaction extension pipeline of a specific version.

F(F)

The transaction extension pipeline of a specific version.

G(G)

The transaction extension pipeline of a specific version.

H(H)

The transaction extension pipeline of a specific version.

I(I)

The transaction extension pipeline of a specific version.

J(J)

The transaction extension pipeline of a specific version.

K(K)

The transaction extension pipeline of a specific version.

L(L)

The transaction extension pipeline of a specific version.

M(M)

The transaction extension pipeline of a specific version.

N(N)

The transaction extension pipeline of a specific version.

O(O)

The transaction extension pipeline of a specific version.

P(P)

The transaction extension pipeline of a specific version.

Q(Q)

The transaction extension pipeline of a specific version.

R(R)

The transaction extension pipeline of a specific version.

S(S)

The transaction extension pipeline of a specific version.

T(T)

The transaction extension pipeline of a specific version.

U(U)

The transaction extension pipeline of a specific version.

V(V)

The transaction extension pipeline of a specific version.

W(W)

The transaction extension pipeline of a specific version.

X(X)

The transaction extension pipeline of a specific version.

Y(Y)

The transaction extension pipeline of a specific version.

Z(Z)

The transaction extension pipeline of a specific version.

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone, M: Clone, N: Clone, O: Clone, P: Clone, Q: Clone, R: Clone, S: Clone, T: Clone, U: Clone, V: Clone, W: Clone, X: Clone, Y: Clone, Z: Clone> Clone for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn clone( &self, ) -> MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug, I: Debug, J: Debug, K: Debug, L: Debug, M: Debug, N: Debug, O: Debug, P: Debug, Q: Debug, R: Debug, S: Debug, T: Debug, U: Debug, V: Debug, W: Debug, X: Debug, Y: Debug, Z: Debug> Debug for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: DecodeWithVersion + MultiVersionItem, B: DecodeWithVersion + MultiVersionItem, C: DecodeWithVersion + MultiVersionItem, D: DecodeWithVersion + MultiVersionItem, E: DecodeWithVersion + MultiVersionItem, F: DecodeWithVersion + MultiVersionItem, G: DecodeWithVersion + MultiVersionItem, H: DecodeWithVersion + MultiVersionItem, I: DecodeWithVersion + MultiVersionItem, J: DecodeWithVersion + MultiVersionItem, K: DecodeWithVersion + MultiVersionItem, L: DecodeWithVersion + MultiVersionItem, M: DecodeWithVersion + MultiVersionItem, N: DecodeWithVersion + MultiVersionItem, O: DecodeWithVersion + MultiVersionItem, P: DecodeWithVersion + MultiVersionItem, Q: DecodeWithVersion + MultiVersionItem, R: DecodeWithVersion + MultiVersionItem, S: DecodeWithVersion + MultiVersionItem, T: DecodeWithVersion + MultiVersionItem, U: DecodeWithVersion + MultiVersionItem, V: DecodeWithVersion + MultiVersionItem, W: DecodeWithVersion + MultiVersionItem, X: DecodeWithVersion + MultiVersionItem, Y: DecodeWithVersion + MultiVersionItem, Z: DecodeWithVersion + MultiVersionItem> DecodeWithVersion for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn decode_with_version<CodecInput: Input>( extension_version: u8, input: &mut CodecInput, ) -> Result<Self, Error>

Decode the type from the given version and input.

impl<A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode> Encode for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

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 encode_to<CodecOutput: Output + ?Sized>(&self, dest: &mut CodecOutput)

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

fn encoded_size(&self) -> usize

Calculates the encoded size.

fn using_encoded<FunctionResult, Function: FnOnce(&[u8]) -> FunctionResult>( &self, f: Function, ) -> FunctionResult

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

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L: PartialEq, M: PartialEq, N: PartialEq, O: PartialEq, P: PartialEq, Q: PartialEq, R: PartialEq, S: PartialEq, T: PartialEq, U: PartialEq, V: PartialEq, W: PartialEq, X: PartialEq, Y: PartialEq, Z: PartialEq> PartialEq for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn eq( &self, other: &MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>, ) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Pipeline<Call> + MultiVersionItem, B: Pipeline<Call> + MultiVersionItem, C: Pipeline<Call> + MultiVersionItem, D: Pipeline<Call> + MultiVersionItem, E: Pipeline<Call> + MultiVersionItem, F: Pipeline<Call> + MultiVersionItem, G: Pipeline<Call> + MultiVersionItem, H: Pipeline<Call> + MultiVersionItem, I: Pipeline<Call> + MultiVersionItem, J: Pipeline<Call> + MultiVersionItem, K: Pipeline<Call> + MultiVersionItem, L: Pipeline<Call> + MultiVersionItem, M: Pipeline<Call> + MultiVersionItem, N: Pipeline<Call> + MultiVersionItem, O: Pipeline<Call> + MultiVersionItem, P: Pipeline<Call> + MultiVersionItem, Q: Pipeline<Call> + MultiVersionItem, R: Pipeline<Call> + MultiVersionItem, S: Pipeline<Call> + MultiVersionItem, T: Pipeline<Call> + MultiVersionItem, U: Pipeline<Call> + MultiVersionItem, V: Pipeline<Call> + MultiVersionItem, W: Pipeline<Call> + MultiVersionItem, X: Pipeline<Call> + MultiVersionItem, Y: Pipeline<Call> + MultiVersionItem, Z: Pipeline<Call> + MultiVersionItem, Call: Dispatchable> Pipeline<Call> for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn build_metadata(builder: &mut PipelineMetadataBuilder)

Build the metadata for the versioned transaction extension pipeline.

fn validate_only( &self, origin: DispatchOriginOf<Call>, call: &Call, info: &DispatchInfoOf<Call>, len: usize, source: TransactionSource, ) -> Result<ValidTransaction, TransactionValidityError>

Validate a transaction.

fn dispatch_transaction( self, origin: DispatchOriginOf<Call>, call: Call, info: &DispatchInfoOf<Call>, len: usize, ) -> ApplyExtrinsicResultWithInfo<PostDispatchInfoOf<Call>>

Dispatch a transaction.

fn weight(&self, call: &Call) -> Weight

Return the pre dispatch weight for the given versioned transaction extension pipeline and call.

impl<A: PipelineVersion, B: PipelineVersion, C: PipelineVersion, D: PipelineVersion, E: PipelineVersion, F: PipelineVersion, G: PipelineVersion, H: PipelineVersion, I: PipelineVersion, J: PipelineVersion, K: PipelineVersion, L: PipelineVersion, M: PipelineVersion, N: PipelineVersion, O: PipelineVersion, P: PipelineVersion, Q: PipelineVersion, R: PipelineVersion, S: PipelineVersion, T: PipelineVersion, U: PipelineVersion, V: PipelineVersion, W: PipelineVersion, X: PipelineVersion, Y: PipelineVersion, Z: PipelineVersion> PipelineVersion for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn version(&self) -> u8

Return the version for the given versioned transaction extension pipeline.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> TypeInfo for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

where A: TypeInfo + 'static, B: TypeInfo + 'static, C: TypeInfo + 'static, D: TypeInfo + 'static, E: TypeInfo + 'static, F: TypeInfo + 'static, G: TypeInfo + 'static, H: TypeInfo + 'static, I: TypeInfo + 'static, J: TypeInfo + 'static, K: TypeInfo + 'static, L: TypeInfo + 'static, M: TypeInfo + 'static, N: TypeInfo + 'static, O: TypeInfo + 'static, P: TypeInfo + 'static, Q: TypeInfo + 'static, R: TypeInfo + 'static, S: TypeInfo + 'static, T: TypeInfo + 'static, U: TypeInfo + 'static, V: TypeInfo + 'static, W: TypeInfo + 'static, X: TypeInfo + 'static, Y: TypeInfo + 'static, Z: TypeInfo + 'static,

type Identity = MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<A: DecodeWithVersionWithMemTracking + MultiVersionItem, B: DecodeWithVersionWithMemTracking + MultiVersionItem, C: DecodeWithVersionWithMemTracking + MultiVersionItem, D: DecodeWithVersionWithMemTracking + MultiVersionItem, E: DecodeWithVersionWithMemTracking + MultiVersionItem, F: DecodeWithVersionWithMemTracking + MultiVersionItem, G: DecodeWithVersionWithMemTracking + MultiVersionItem, H: DecodeWithVersionWithMemTracking + MultiVersionItem, I: DecodeWithVersionWithMemTracking + MultiVersionItem, J: DecodeWithVersionWithMemTracking + MultiVersionItem, K: DecodeWithVersionWithMemTracking + MultiVersionItem, L: DecodeWithVersionWithMemTracking + MultiVersionItem, M: DecodeWithVersionWithMemTracking + MultiVersionItem, N: DecodeWithVersionWithMemTracking + MultiVersionItem, O: DecodeWithVersionWithMemTracking + MultiVersionItem, P: DecodeWithVersionWithMemTracking + MultiVersionItem, Q: DecodeWithVersionWithMemTracking + MultiVersionItem, R: DecodeWithVersionWithMemTracking + MultiVersionItem, S: DecodeWithVersionWithMemTracking + MultiVersionItem, T: DecodeWithVersionWithMemTracking + MultiVersionItem, U: DecodeWithVersionWithMemTracking + MultiVersionItem, V: DecodeWithVersionWithMemTracking + MultiVersionItem, W: DecodeWithVersionWithMemTracking + MultiVersionItem, X: DecodeWithVersionWithMemTracking + MultiVersionItem, Y: DecodeWithVersionWithMemTracking + MultiVersionItem, Z: DecodeWithVersionWithMemTracking + MultiVersionItem> DecodeWithVersionWithMemTracking for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq, M: Eq, N: Eq, O: Eq, P: Eq, Q: Eq, R: Eq, S: Eq, T: Eq, U: Eq, V: Eq, W: Eq, X: Eq, Y: Eq, Z: Eq> Eq for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> StructuralPartialEq for MultiVersion<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>