Trait parity_scale_codec::Decode

pub trait Decode: Sized {
    fn decode<I: Input>(value: &mut I) -> Result<Self, Error>;
}

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

Required methods

fn decode<I: Input>(value: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

Loading content...

Implementations on Foreign Types

impl<T: Decode, E: Decode> Decode for Result<T, E>

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

impl<T: Decode> Decode for Option<T>

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

impl Decode for NonZeroI8

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

impl Decode for NonZeroI16

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

impl Decode for NonZeroI32

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

impl Decode for NonZeroI64

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

impl Decode for NonZeroI128

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

impl Decode for NonZeroU8

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

impl Decode for NonZeroU16

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

impl Decode for NonZeroU32

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

impl Decode for NonZeroU64

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

impl Decode for NonZeroU128

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

impl<T: Decode> Decode for [T; 1]

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

impl<T: Decode> Decode for [T; 2]

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

impl<T: Decode> Decode for [T; 3]

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

impl<T: Decode> Decode for [T; 4]

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

impl<T: Decode> Decode for [T; 5]

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

impl<T: Decode> Decode for [T; 6]

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

impl<T: Decode> Decode for [T; 7]

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

impl<T: Decode> Decode for [T; 8]

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

impl<T: Decode> Decode for [T; 9]

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

impl<T: Decode> Decode for [T; 10]

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

impl<T: Decode> Decode for [T; 11]

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

impl<T: Decode> Decode for [T; 12]

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

impl<T: Decode> Decode for [T; 13]

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

impl<T: Decode> Decode for [T; 14]

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

impl<T: Decode> Decode for [T; 15]

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

impl<T: Decode> Decode for [T; 16]

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

impl<T: Decode> Decode for [T; 17]

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

impl<T: Decode> Decode for [T; 18]

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

impl<T: Decode> Decode for [T; 19]

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

impl<T: Decode> Decode for [T; 20]

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

impl<T: Decode> Decode for [T; 21]

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

impl<T: Decode> Decode for [T; 22]

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

impl<T: Decode> Decode for [T; 23]

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

impl<T: Decode> Decode for [T; 24]

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

impl<T: Decode> Decode for [T; 25]

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

impl<T: Decode> Decode for [T; 26]

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

impl<T: Decode> Decode for [T; 27]

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

impl<T: Decode> Decode for [T; 28]

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

impl<T: Decode> Decode for [T; 29]

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

impl<T: Decode> Decode for [T; 30]

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

impl<T: Decode> Decode for [T; 31]

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

impl<T: Decode> Decode for [T; 32]

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

impl<T: Decode> Decode for [T; 33]

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

impl<T: Decode> Decode for [T; 34]

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

impl<T: Decode> Decode for [T; 35]

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

impl<T: Decode> Decode for [T; 36]

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

impl<T: Decode> Decode for [T; 37]

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

impl<T: Decode> Decode for [T; 38]

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

impl<T: Decode> Decode for [T; 39]

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

impl<T: Decode> Decode for [T; 40]

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

impl<T: Decode> Decode for [T; 41]

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

impl<T: Decode> Decode for [T; 42]

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

impl<T: Decode> Decode for [T; 43]

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

impl<T: Decode> Decode for [T; 44]

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

impl<T: Decode> Decode for [T; 45]

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

impl<T: Decode> Decode for [T; 46]

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

impl<T: Decode> Decode for [T; 47]

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

impl<T: Decode> Decode for [T; 48]

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

impl<T: Decode> Decode for [T; 49]

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

impl<T: Decode> Decode for [T; 50]

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

impl<T: Decode> Decode for [T; 51]

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

impl<T: Decode> Decode for [T; 52]

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

impl<T: Decode> Decode for [T; 53]

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

impl<T: Decode> Decode for [T; 54]

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

impl<T: Decode> Decode for [T; 55]

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

impl<T: Decode> Decode for [T; 56]

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

impl<T: Decode> Decode for [T; 57]

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

impl<T: Decode> Decode for [T; 58]

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

impl<T: Decode> Decode for [T; 59]

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

impl<T: Decode> Decode for [T; 60]

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

impl<T: Decode> Decode for [T; 61]

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

impl<T: Decode> Decode for [T; 62]

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

impl<T: Decode> Decode for [T; 63]

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

impl<T: Decode> Decode for [T; 64]

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

impl<T: Decode> Decode for [T; 65]

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

impl<T: Decode> Decode for [T; 66]

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

impl<T: Decode> Decode for [T; 67]

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

impl<T: Decode> Decode for [T; 68]

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

impl<T: Decode> Decode for [T; 69]

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

impl<T: Decode> Decode for [T; 70]

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

impl<T: Decode> Decode for [T; 71]

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

impl<T: Decode> Decode for [T; 72]

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

impl<T: Decode> Decode for [T; 73]

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

impl<T: Decode> Decode for [T; 74]

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

impl<T: Decode> Decode for [T; 75]

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

impl<T: Decode> Decode for [T; 76]

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

impl<T: Decode> Decode for [T; 77]

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

impl<T: Decode> Decode for [T; 78]

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

impl<T: Decode> Decode for [T; 79]

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

impl<T: Decode> Decode for [T; 80]

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

impl<T: Decode> Decode for [T; 81]

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

impl<T: Decode> Decode for [T; 82]

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

impl<T: Decode> Decode for [T; 83]

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

impl<T: Decode> Decode for [T; 84]

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

impl<T: Decode> Decode for [T; 85]

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

impl<T: Decode> Decode for [T; 86]

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

impl<T: Decode> Decode for [T; 87]

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

impl<T: Decode> Decode for [T; 88]

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

impl<T: Decode> Decode for [T; 89]

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

impl<T: Decode> Decode for [T; 90]

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

impl<T: Decode> Decode for [T; 91]

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

impl<T: Decode> Decode for [T; 92]

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

impl<T: Decode> Decode for [T; 93]

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

impl<T: Decode> Decode for [T; 94]

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

impl<T: Decode> Decode for [T; 95]

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

impl<T: Decode> Decode for [T; 96]

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

impl<T: Decode> Decode for [T; 97]

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

impl<T: Decode> Decode for [T; 98]

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

impl<T: Decode> Decode for [T; 99]

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

impl<T: Decode> Decode for [T; 100]

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

impl<T: Decode> Decode for [T; 101]

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

impl<T: Decode> Decode for [T; 102]

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

impl<T: Decode> Decode for [T; 103]

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

impl<T: Decode> Decode for [T; 104]

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

impl<T: Decode> Decode for [T; 105]

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

impl<T: Decode> Decode for [T; 106]

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

impl<T: Decode> Decode for [T; 107]

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

impl<T: Decode> Decode for [T; 108]

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

impl<T: Decode> Decode for [T; 109]

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

impl<T: Decode> Decode for [T; 110]

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

impl<T: Decode> Decode for [T; 111]

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

impl<T: Decode> Decode for [T; 112]

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

impl<T: Decode> Decode for [T; 113]

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

impl<T: Decode> Decode for [T; 114]

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

impl<T: Decode> Decode for [T; 115]

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

impl<T: Decode> Decode for [T; 116]

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

impl<T: Decode> Decode for [T; 117]

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

impl<T: Decode> Decode for [T; 118]

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

impl<T: Decode> Decode for [T; 119]

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

impl<T: Decode> Decode for [T; 120]

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

impl<T: Decode> Decode for [T; 121]

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

impl<T: Decode> Decode for [T; 122]

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

impl<T: Decode> Decode for [T; 123]

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

impl<T: Decode> Decode for [T; 124]

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

impl<T: Decode> Decode for [T; 125]

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

impl<T: Decode> Decode for [T; 126]

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

impl<T: Decode> Decode for [T; 127]

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

impl<T: Decode> Decode for [T; 128]

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

impl<T: Decode> Decode for [T; 129]

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

impl<T: Decode> Decode for [T; 130]

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

impl<T: Decode> Decode for [T; 131]

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

impl<T: Decode> Decode for [T; 132]

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

impl<T: Decode> Decode for [T; 133]

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

impl<T: Decode> Decode for [T; 134]

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

impl<T: Decode> Decode for [T; 135]

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

impl<T: Decode> Decode for [T; 136]

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

impl<T: Decode> Decode for [T; 137]

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

impl<T: Decode> Decode for [T; 138]

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

impl<T: Decode> Decode for [T; 139]

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

impl<T: Decode> Decode for [T; 140]

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

impl<T: Decode> Decode for [T; 141]

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

impl<T: Decode> Decode for [T; 142]

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

impl<T: Decode> Decode for [T; 143]

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

impl<T: Decode> Decode for [T; 144]

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

impl<T: Decode> Decode for [T; 145]

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

impl<T: Decode> Decode for [T; 146]

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

impl<T: Decode> Decode for [T; 147]

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

impl<T: Decode> Decode for [T; 148]

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

impl<T: Decode> Decode for [T; 149]

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

impl<T: Decode> Decode for [T; 150]

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

impl<T: Decode> Decode for [T; 151]

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

impl<T: Decode> Decode for [T; 152]

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

impl<T: Decode> Decode for [T; 153]

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

impl<T: Decode> Decode for [T; 154]

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

impl<T: Decode> Decode for [T; 155]

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

impl<T: Decode> Decode for [T; 156]

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

impl<T: Decode> Decode for [T; 157]

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

impl<T: Decode> Decode for [T; 158]

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

impl<T: Decode> Decode for [T; 159]

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

impl<T: Decode> Decode for [T; 160]

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

impl<T: Decode> Decode for [T; 161]

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

impl<T: Decode> Decode for [T; 162]

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

impl<T: Decode> Decode for [T; 163]

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

impl<T: Decode> Decode for [T; 164]

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

impl<T: Decode> Decode for [T; 165]

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

impl<T: Decode> Decode for [T; 166]

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

impl<T: Decode> Decode for [T; 167]

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

impl<T: Decode> Decode for [T; 168]

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

impl<T: Decode> Decode for [T; 169]

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

impl<T: Decode> Decode for [T; 170]

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

impl<T: Decode> Decode for [T; 171]

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

impl<T: Decode> Decode for [T; 172]

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

impl<T: Decode> Decode for [T; 173]

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

impl<T: Decode> Decode for [T; 174]

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

impl<T: Decode> Decode for [T; 175]

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

impl<T: Decode> Decode for [T; 176]

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

impl<T: Decode> Decode for [T; 177]

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

impl<T: Decode> Decode for [T; 178]

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

impl<T: Decode> Decode for [T; 179]

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

impl<T: Decode> Decode for [T; 180]

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

impl<T: Decode> Decode for [T; 181]

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

impl<T: Decode> Decode for [T; 182]

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

impl<T: Decode> Decode for [T; 183]

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

impl<T: Decode> Decode for [T; 184]

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

impl<T: Decode> Decode for [T; 185]

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

impl<T: Decode> Decode for [T; 186]

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

impl<T: Decode> Decode for [T; 187]

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

impl<T: Decode> Decode for [T; 188]

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

impl<T: Decode> Decode for [T; 189]

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

impl<T: Decode> Decode for [T; 190]

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

impl<T: Decode> Decode for [T; 191]

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

impl<T: Decode> Decode for [T; 192]

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

impl<T: Decode> Decode for [T; 193]

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

impl<T: Decode> Decode for [T; 194]

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

impl<T: Decode> Decode for [T; 195]

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

impl<T: Decode> Decode for [T; 196]

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

impl<T: Decode> Decode for [T; 197]

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

impl<T: Decode> Decode for [T; 198]

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

impl<T: Decode> Decode for [T; 199]

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

impl<T: Decode> Decode for [T; 200]

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

impl<T: Decode> Decode for [T; 201]

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

impl<T: Decode> Decode for [T; 202]

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

impl<T: Decode> Decode for [T; 203]

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

impl<T: Decode> Decode for [T; 204]

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

impl<T: Decode> Decode for [T; 205]

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

impl<T: Decode> Decode for [T; 206]

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

impl<T: Decode> Decode for [T; 207]

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

impl<T: Decode> Decode for [T; 208]

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

impl<T: Decode> Decode for [T; 209]

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

impl<T: Decode> Decode for [T; 210]

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

impl<T: Decode> Decode for [T; 211]

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

impl<T: Decode> Decode for [T; 212]

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

impl<T: Decode> Decode for [T; 213]

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

impl<T: Decode> Decode for [T; 214]

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

impl<T: Decode> Decode for [T; 215]

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

impl<T: Decode> Decode for [T; 216]

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

impl<T: Decode> Decode for [T; 217]

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

impl<T: Decode> Decode for [T; 218]

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

impl<T: Decode> Decode for [T; 219]

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

impl<T: Decode> Decode for [T; 220]

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

impl<T: Decode> Decode for [T; 221]

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

impl<T: Decode> Decode for [T; 222]

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

impl<T: Decode> Decode for [T; 223]

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

impl<T: Decode> Decode for [T; 224]

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

impl<T: Decode> Decode for [T; 225]

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

impl<T: Decode> Decode for [T; 226]

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

impl<T: Decode> Decode for [T; 227]

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

impl<T: Decode> Decode for [T; 228]

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

impl<T: Decode> Decode for [T; 229]

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

impl<T: Decode> Decode for [T; 230]

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

impl<T: Decode> Decode for [T; 231]

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

impl<T: Decode> Decode for [T; 232]

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

impl<T: Decode> Decode for [T; 233]

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

impl<T: Decode> Decode for [T; 234]

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

impl<T: Decode> Decode for [T; 235]

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

impl<T: Decode> Decode for [T; 236]

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

impl<T: Decode> Decode for [T; 237]

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

impl<T: Decode> Decode for [T; 238]

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

impl<T: Decode> Decode for [T; 239]

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

impl<T: Decode> Decode for [T; 240]

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

impl<T: Decode> Decode for [T; 241]

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

impl<T: Decode> Decode for [T; 242]

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

impl<T: Decode> Decode for [T; 243]

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

impl<T: Decode> Decode for [T; 244]

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

impl<T: Decode> Decode for [T; 245]

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

impl<T: Decode> Decode for [T; 246]

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

impl<T: Decode> Decode for [T; 247]

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

impl<T: Decode> Decode for [T; 248]

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

impl<T: Decode> Decode for [T; 249]

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

impl<T: Decode> Decode for [T; 250]

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

impl<T: Decode> Decode for [T; 251]

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

impl<T: Decode> Decode for [T; 252]

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

impl<T: Decode> Decode for [T; 253]

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

impl<T: Decode> Decode for [T; 254]

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

impl<T: Decode> Decode for [T; 255]

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

impl<T: Decode> Decode for [T; 256]

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

impl<T: Decode> Decode for [T; 384]

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

impl<T: Decode> Decode for [T; 512]

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

impl<T: Decode> Decode for [T; 768]

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

impl<T: Decode> Decode for [T; 1024]

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

impl<T: Decode> Decode for [T; 2048]

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

impl<T: Decode> Decode for [T; 4096]

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

impl<T: Decode> Decode for [T; 8192]

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

impl<T: Decode> Decode for [T; 16384]

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

impl<T: Decode> Decode for [T; 32768]

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

impl<'a, T: ToOwned + ?Sized> Decode for Cow<'a, T> where
    <T as ToOwned>::Owned: Decode, 

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

impl<T> Decode for PhantomData<T>

fn decode<I: Input>(_input: &mut I) -> Result<Self, Error>

impl Decode for String

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

impl<T: Decode> Decode for Vec<T>

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

impl<K: Decode + Ord, V: Decode> Decode for BTreeMap<K, V>

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

impl<T: Decode + Ord> Decode for BTreeSet<T>

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

impl<T: Decode> Decode for LinkedList<T>

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

impl<T: Decode + Ord> Decode for BinaryHeap<T>

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

impl<T: Decode> Decode for VecDeque<T>

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

impl Decode for ()

fn decode<I: Input>(_: &mut I) -> Result<(), Error>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<P0: Decode, Q0: Decode, R0: Decode> Decode for (P0, Q0, R0)

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

impl<Q0: Decode, R0: Decode> Decode for (Q0, R0)

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

impl<R0: Decode> Decode for (R0,)

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

impl Decode for u16

const TYPE_INFO: TypeInfo

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

impl Decode for u32

const TYPE_INFO: TypeInfo

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

impl Decode for u64

const TYPE_INFO: TypeInfo

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

impl Decode for u128

const TYPE_INFO: TypeInfo

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

impl Decode for i16

const TYPE_INFO: TypeInfo

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

impl Decode for i32

const TYPE_INFO: TypeInfo

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

impl Decode for i64

const TYPE_INFO: TypeInfo

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

impl Decode for i128

const TYPE_INFO: TypeInfo

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

impl Decode for u8

const TYPE_INFO: TypeInfo

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

impl Decode for i8

const TYPE_INFO: TypeInfo

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

impl Decode for bool

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

impl Decode for Duration

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

Loading content...

Implementors

impl Decode for Compact<u8>

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

impl Decode for Compact<u16>

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

impl Decode for Compact<u32>

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

impl Decode for Compact<u64>

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

impl Decode for Compact<u128>

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

impl Decode for Compact<()>

fn decode<I: Input>(_input: &mut I) -> Result<Self, Error>

impl Decode for OptionBool

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

impl<T> Decode for Compact<T> where
    T: CompactAs,
    Compact<T::As>: Decode, 

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

impl<T, X> Decode for X where
    T: Decode + Into<X>,
    X: WrapperTypeDecode<Wrapped = T>, 

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

Loading content...