Trait frame_support::dispatch::Encode

pub trait Encode {
    fn size_hint(&self) -> usize { ... }
    fn encode_to<T>(&self, dest: &mut T)
    where
        T: Output,
    { ... }
    fn encode(&self) -> Vec<u8> { ... }
    fn using_encoded<R, F>(&self, f: F) -> R
    where
        F: FnOnce(&[u8]) -> R,
    { ... }
}

Trait that allows zero-copy write of value-references to slices in LE format.

Implementations should override using_encoded for value types and encode_to and size_hint for allocating types. Wrapper types should override all methods.

Provided methods

fn size_hint(&self) -> usize

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

This method is used inside default implementation of encode to avoid re-allocations.

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

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

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.

Loading content...

Implementations on Foreign Types

impl<T> Encode for [T; 56] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 235] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 228] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 64] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 127] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 223] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for u32

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 39] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 162] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 136] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 10] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 210] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for i32

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 2] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 30] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 59] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 19] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 178] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 63] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 244] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 128] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 26] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 215] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 157] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 192] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 211] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<N0, O0, P0, Q0, R0> Encode for (N0, O0, P0, Q0, R0) where
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 201] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 197] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 50] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 54] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 186] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 154] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 185] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 110] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 37] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 14] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 107] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 8] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 182] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 167] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 198] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 103] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 4] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 148] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 43] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 114] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 189] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 58] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 61] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 213] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for OptionBool

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 40] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for i8

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 216] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 251] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 181] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 106] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 60] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 196] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 68] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 206] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 124] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 70] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 48] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 4096] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 72] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 38] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 204] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for Compact<T> where
    CompactRef<'a, T>: for<'a> Encode, 

fn size_hint(&self) -> usize

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

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

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

impl<K, V> Encode for BTreeMap<K, V> where
    K: Encode,
    V: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 7] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 118] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<O0, P0, Q0, R0> Encode for (O0, P0, Q0, R0) where
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 168] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 195] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<M0, N0, O0, P0, Q0, R0> Encode for (M0, N0, O0, P0, Q0, R0) where
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 242] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 207] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 100] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 212] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 46] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 190] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 83] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 122] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 73] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 6] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 249] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 145] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 92] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 67] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 149] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 55] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for i16

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 123] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 79] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 28] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 243] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 187] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 65] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 120] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 255] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 121] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 247] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 234] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 87] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 112] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    B0: Encode,
    C0: Encode,
    D0: Encode,
    E0: Encode,
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 125] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for Option<T> where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 12] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 44] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 170] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 248] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 133] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 74] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 252] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 165] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 194] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 203] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 69] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 163] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 253] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 1024] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 214] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 66] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 18] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for u64

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 180] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 218] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 137] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 188] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 156] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 164] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 222] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 245] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    D0: Encode,
    E0: Encode,
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 119] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 13] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 78] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 254] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 111] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 143] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 240] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for u128

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 47] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 20] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 31] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 225] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 241] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 205] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 91] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 34] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 85] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 208] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 45] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 135] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    A0: Encode,
    B0: Encode,
    C0: Encode,
    D0: Encode,
    E0: Encode,
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 246] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 384] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 104] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    C0: Encode,
    D0: Encode,
    E0: Encode,
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 49] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 96] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 132] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 224] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 155] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 82] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 36] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 239] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 176] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 32768] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 237] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for bool

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 29] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 126] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 109] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 134] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 117] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 173] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 146] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for i128

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 227] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 17] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 183] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 33] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for i64

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 102] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 153] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 219] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 11] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 174] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 250] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 209] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<L0, M0, N0, O0, P0, Q0, R0> Encode for (L0, M0, N0, O0, P0, Q0, R0) where
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 184] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 16384] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<R0> Encode for (R0,) where
    R0: Encode, 

fn size_hint(&self) -> usize

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

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

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

impl<T> Encode for [T; 105] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 172] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 21] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 84] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 142] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 35] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 76] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 200] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 98] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 101] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 94] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 202] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<Q0, R0> Encode for (Q0, R0) where
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 230] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 93] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 97] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 160] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 226] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 130] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 1] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 147] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 77] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<P0, Q0, R0> Encode for (P0, Q0, R0) where
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for VecDeque<T> where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 161] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 62] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 238] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 42] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 23] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for BinaryHeap<T> where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 99] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 171] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 57] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 151] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 169] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 51] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 166] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 27] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 129] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 90] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 179] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 138] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    E0: Encode,
    F0: Encode,
    G0: Encode,
    H0: Encode,
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 144] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 81] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 229] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 115] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 159] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 131] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 139] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 32] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 191] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 221] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 88] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    I0: Encode,
    J0: Encode,
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 768] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 150] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for u8

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl Encode for Duration

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 236] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 152] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 108] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 233] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for BTreeSet<T> where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 80] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 232] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 75] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 217] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 52] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 141] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 41] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for ()

fn encode_to<W>(&self, _dest: &mut W) where
    W: Output, 

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

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

impl Encode for str

fn size_hint(&self) -> usize

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

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

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

impl<T> Encode for [T; 53] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 95] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 24] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 220] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 3] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 199] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 5] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for LinkedList<T> where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 116] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 2048] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 22] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<K0, L0, M0, N0, O0, P0, Q0, R0> Encode for (K0, L0, M0, N0, O0, P0, Q0, R0) where
    K0: Encode,
    L0: Encode,
    M0: Encode,
    N0: Encode,
    O0: Encode,
    P0: Encode,
    Q0: Encode,
    R0: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 140] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 158] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 9] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 193] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 16] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 231] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 177] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 86] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 256] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 25] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 113] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 89] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for u16

const TYPE_INFO: TypeInfo

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 512] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 15] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 71] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 8192] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T> Encode for [T; 175] where
    T: Encode, 

fn size_hint(&self) -> usize

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

impl Encode for Signature

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

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

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

impl Encode for OpaqueMetadata

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

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

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

impl Encode for Duration

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

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

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

impl Encode for Signature

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

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

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

impl Encode for Signature

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

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

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

impl Encode for Timestamp

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

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

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

impl Encode for StorageKind

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

impl Encode for HttpRequestId

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

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

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

impl Encode for OpaquePeerId

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

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

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

impl Encode for HttpRequestStatus

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

impl Encode for Public

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

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

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

impl Encode for ExternEntity

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

impl Encode for OpaqueNetworkState

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

impl Encode for LogLevel

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

impl Encode for NeverNativeValue

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

impl Encode for Public

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

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

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

impl Encode for ChangesTrieConfiguration

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

impl Encode for KeyTypeId

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

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

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

impl Encode for Entry

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

impl Encode for LocalizedSignature

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

impl Encode for AccountId32

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

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

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

impl Encode for HttpError

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

impl Encode for HostError

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

impl Encode for DeriveJunction

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

impl Encode for OpaqueMultiaddr

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

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

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

impl Encode for Public

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

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

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

impl Encode for EnvironmentDefinition

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

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

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

impl Encode for Value

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

impl Encode for ReturnValue

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

impl Encode for U256

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

impl Encode for U128

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

impl Encode for H256

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

impl Encode for H512

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

impl Encode for H160

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

impl Encode for U512

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

impl Encode for StorageProof

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

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

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

impl Encode for EcdsaVerifyError

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

impl Encode for RuntimeMetadataDeprecated

fn encode_to<W>(&self, _dest: &mut W) where
    W: Output, 

impl Encode for RuntimeMetadataV11

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

impl<Call, Extra> Encode for TestXt<Call, Extra> where
    Call: Encode,
    Option<(u64, Extra)>: Encode, 

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

impl Encode for RuntimeString

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

impl<Xt> Encode for Block<Xt> where
    Vec<Xt>: Encode, 

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

impl Encode for BadOrigin

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

impl Encode for UnknownTransaction

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

impl Encode for InvalidTransaction

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

impl<Hashing> Encode for RandomNumberGenerator<Hashing> where
    Hashing: Hash,
    <Hashing as Hash>::Output: Encode, 

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

impl Encode for MultiSignature

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

impl<Xt> Encode for ExtrinsicWrapper<Xt> where
    Xt: Encode, 

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

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

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

impl<Hash> Encode for Digest<Hash> where
    Hash: Encode + Decode,
    Vec<DigestItem<Hash>>: Encode, 

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

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

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

impl<Hash> Encode for DigestItem<Hash> where
    Hash: Encode, 

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

impl Encode for Era

fn encode_to<T>(&self, output: &mut T) where
    T: Output, 

impl<Number, Hash> Encode for Header<Number, Hash> where
    Hash: Hash,
    Number: HasCompact + Copy + Into<U256> + TryFrom<U256>,
    <Hash as Hash>::Output: Encode, 

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

impl Encode for OpaqueExtrinsic

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

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

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

impl<Header, Extrinsic> Encode for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Encode,
    Vec<Extrinsic>: Encode, 

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

impl Encode for LookupError

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

impl Encode for ModuleId

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

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

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

impl<Block> Encode for SignedBlock<Block> where
    Block: Encode, 

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

impl Encode for ChangesTrieSignal

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

impl Encode for TransactionValidityError

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

impl Encode for UintAuthorityId

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

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

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

impl<Address, Call, Signature, Extra> Encode for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Address: Encode,
    Call: Encode,
    Extra: SignedExtension,
    Signature: Encode, 

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

impl Encode for Header

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

impl<Call, Extra> Encode for SignedPayload<Call, Extra> where
    Call: Encode,
    Extra: SignedExtension, 

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

Get an encoded version of this payload.

Payloads longer than 256 bytes are going to be blake2_256-hashed.

impl Encode for MultiSigner

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

impl Encode for AnySignature

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

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

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

impl<'a, Hash> Encode for DigestItemRef<'a, Hash> where
    Hash: Encode, 

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

impl Encode for ValidTransaction

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

impl Encode for Signature

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

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

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

impl Encode for Public

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

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

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

impl Encode for Signature

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

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

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

impl Encode for Public

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

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

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

impl Encode for Perquintill

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

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

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

impl Encode for Perbill

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

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

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

impl Encode for Percent

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

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

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

impl Encode for Fixed64

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

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

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

impl Encode for Permill

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

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

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

impl<E> Encode for MakeFatalError<E> where
    E: Encode, 

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

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

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

impl Encode for CheckInherentsResult

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

impl Encode for Error

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

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

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

impl Encode for InherentData

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

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

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

Loading content...

Implementors

impl Encode for DispatchError

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

impl Encode for RuntimeMetadata

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

impl Encode for StorageEntryModifier

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

impl Encode for StorageEntryType

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

impl Encode for StorageHasher

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

impl Encode for WithdrawReason

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

impl Encode for DispatchClass

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

impl Encode for ErrorMetadata

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

impl Encode for FunctionArgumentMetadata

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

impl Encode for FunctionMetadata

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

impl Encode for ModuleConstantMetadata

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

impl Encode for EventMetadata

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

impl Encode for OuterEventMetadata

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

impl Encode for DefaultByteGetter

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

impl Encode for ExtrinsicMetadata

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

impl Encode for ModuleMetadata

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

impl Encode for RuntimeMetadataPrefixed

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

impl Encode for StorageEntryMetadata

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

impl Encode for StorageMetadata

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

impl Encode for WithdrawReasons

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

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

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

impl Encode for DispatchInfo

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

impl<B, O> Encode for DecodeDifferent<B, O> where
    B: Encode + 'static,
    O: Encode + 'static, 

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

impl<E> Encode for FnEncode<E> where
    E: Encode, 

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

impl<T> Encode for PhantomData<T>

fn encode_to<W>(&self, _dest: &mut W) where
    W: Output, 

impl<T, E> Encode for Result<T, E> where
    E: Encode,
    T: Encode, 

fn size_hint(&self) -> usize

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

impl<T, X> Encode for X where
    T: Encode + ?Sized,
    X: WrapperTypeEncode<Target = T>, 

fn size_hint(&self) -> usize

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

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

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

Loading content...