[−][src]Trait elrond_codec::NestedDecode
Trait that allows zero-copy read of value-references from slices in LE format.
Provided methods
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R
input: &mut I,
f: F
) -> R
Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation.
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>
input: &mut I
) -> Result<Self, DecodeError>
Implementations on Foreign Types
impl<T: NestedDecode> NestedDecode for Vec<T>[src]
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T: NestedDecode> NestedDecode for Option<T>[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for Box<T>[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for NonZeroUsize[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
Implementors
impl NestedDecode for ()[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
_input: &mut I,
f: F
) -> R[src]
_input: &mut I,
f: F
) -> R
impl NestedDecode for bool[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for i8[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for i16[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for i32[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for i64[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for isize[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for u8[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for u16[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for u32[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for u64[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl NestedDecode for usize[src]
const TYPE_INFO: TypeInfo[src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T0> NestedDecode for (T0,) where
T0: NestedDecode, [src]
T0: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1> NestedDecode for (T0, T1) where
T0: NestedDecode,
T1: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2> NestedDecode for (T0, T1, T2) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3> NestedDecode for (T0, T1, T2, T3) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4> NestedDecode for (T0, T1, T2, T3, T4) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5> NestedDecode for (T0, T1, T2, T3, T4, T5) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6> NestedDecode for (T0, T1, T2, T3, T4, T5, T6) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode,
T14: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode,
T14: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> NestedDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode,
T14: NestedDecode,
T15: NestedDecode, [src]
T0: NestedDecode,
T1: NestedDecode,
T2: NestedDecode,
T3: NestedDecode,
T4: NestedDecode,
T5: NestedDecode,
T6: NestedDecode,
T7: NestedDecode,
T8: NestedDecode,
T9: NestedDecode,
T10: NestedDecode,
T11: NestedDecode,
T12: NestedDecode,
T13: NestedDecode,
T14: NestedDecode,
T15: NestedDecode,
fn dep_decode_to<I: NestedDecodeInput>(
input: &mut I
) -> Result<Self, DecodeError>[src]
input: &mut I
) -> Result<Self, DecodeError>
impl<T: NestedDecode> NestedDecode for [T; 1][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 2][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 3][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 4][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 5][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 6][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 7][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 8][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 9][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 10][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 11][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 12][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 13][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 14][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 15][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 16][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 17][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 18][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 19][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 20][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 21][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 22][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 23][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 24][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 25][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 26][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 27][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 28][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 29][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 30][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 31][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 32][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 33][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 34][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 35][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 36][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 37][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 38][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 39][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 40][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 41][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 42][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 43][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 44][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 45][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 46][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 47][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 48][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 49][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 50][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 51][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 52][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 53][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 54][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 55][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 56][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 57][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 58][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 59][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 60][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 61][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 62][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 63][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 64][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 65][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 66][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 67][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 68][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 69][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 70][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 71][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 72][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 73][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 74][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 75][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 76][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 77][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 78][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 79][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 80][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 81][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 82][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 83][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 84][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 85][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 86][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 87][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 88][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 89][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 90][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 91][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 92][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 93][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 94][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 95][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 96][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 97][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 98][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 99][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 100][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 101][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 102][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 103][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 104][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 105][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 106][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 107][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 108][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 109][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 110][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 111][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 112][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 113][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 114][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 115][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 116][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 117][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 118][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 119][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 120][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 121][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 122][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 123][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 124][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 125][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 126][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 127][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 128][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 129][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 130][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 131][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 132][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 133][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 134][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 135][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 136][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 137][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 138][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 139][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 140][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 141][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 142][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 143][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 144][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 145][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 146][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 147][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 148][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 149][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 150][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 151][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 152][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 153][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 154][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 155][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 156][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 157][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 158][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 159][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 160][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 161][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 162][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 163][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 164][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 165][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 166][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 167][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 168][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 169][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 170][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 171][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 172][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 173][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 174][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 175][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 176][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 177][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 178][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 179][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 180][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 181][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 182][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 183][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 184][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 185][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 186][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 187][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 188][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 189][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 190][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 191][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 192][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 193][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 194][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 195][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 196][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 197][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 198][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 199][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 200][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 201][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 202][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 203][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 204][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 205][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 206][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 207][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 208][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 209][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 210][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 211][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 212][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 213][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 214][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 215][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 216][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 217][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 218][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 219][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 220][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 221][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 222][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 223][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 224][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 225][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 226][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 227][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 228][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 229][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 230][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 231][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 232][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 233][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 234][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 235][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 236][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 237][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 238][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 239][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 240][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 241][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 242][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 243][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 244][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 245][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 246][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 247][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 248][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 249][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 250][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 251][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 252][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 253][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 254][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 255][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 256][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 384][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 512][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 768][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 1024][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 2048][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 4096][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 8192][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 16384][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R
impl<T: NestedDecode> NestedDecode for [T; 32768][src]
fn dep_decode<I: NestedDecodeInput, R, F: FnOnce(Result<Self, DecodeError>) -> R>(
input: &mut I,
f: F
) -> R[src]
input: &mut I,
f: F
) -> R