Trait rustc_ap_serialize::Decodable

pub trait Decodable: Sized {
    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
}

Required methods

fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>

Loading content...

Implementations on Foreign Types

impl<A: Array<Item: Decodable>> Decodable for SmallVec<A>

fn decode<D: Decoder>(d: &mut D) -> Result<SmallVec<A>, D::Error>

impl<T: Decodable> Decodable for LinkedList<T>

fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error>

impl<T: Decodable> Decodable for VecDeque<T>

fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error>

impl<K, V> Decodable for BTreeMap<K, V> where
    K: Decodable + PartialEq + Ord,
    V: Decodable, 

fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error>

impl<T> Decodable for BTreeSet<T> where
    T: Decodable + PartialEq + Ord, 

fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error>

impl<K, V, S> Decodable for HashMap<K, V, S> where
    K: Decodable + Hash + Eq,
    V: Decodable,
    S: BuildHasher + Default, 

fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error>

impl<T, S> Decodable for HashSet<T, S> where
    T: Decodable + Hash + Eq,
    S: BuildHasher + Default, 

fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error>

impl<K, V, S> Decodable for IndexMap<K, V, S> where
    K: Decodable + Hash + Eq,
    V: Decodable,
    S: BuildHasher + Default, 

fn decode<D: Decoder>(d: &mut D) -> Result<IndexMap<K, V, S>, D::Error>

impl<T, S> Decodable for IndexSet<T, S> where
    T: Decodable + Hash + Eq,
    S: BuildHasher + Default, 

fn decode<D: Decoder>(d: &mut D) -> Result<IndexSet<T, S>, D::Error>

impl<T: Decodable> Decodable for Rc<[T]>

fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error>

impl<T: Decodable> Decodable for Arc<[T]>

fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error>

impl Decodable for usize

fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error>

impl Decodable for u8

fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error>

impl Decodable for u16

fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error>

impl Decodable for u32

fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error>

impl Decodable for NonZeroU32

fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>

impl Decodable for u64

fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error>

impl Decodable for u128

fn decode<D: Decoder>(d: &mut D) -> Result<u128, D::Error>

impl Decodable for isize

fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error>

impl Decodable for i8

fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error>

impl Decodable for i16

fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error>

impl Decodable for i32

fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error>

impl Decodable for i64

fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error>

impl Decodable for i128

fn decode<D: Decoder>(d: &mut D) -> Result<i128, D::Error>

impl Decodable for String

fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error>

impl Decodable for f32

fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error>

impl Decodable for f64

fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error>

impl Decodable for bool

fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error>

impl Decodable for char

fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error>

impl Decodable for ()

fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error>

impl<T> Decodable for PhantomData<T>

fn decode<D: Decoder>(d: &mut D) -> Result<PhantomData<T>, D::Error>

impl<T: Decodable> Decodable for Box<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error>

impl<T: Decodable> Decodable for Box<[T]>

fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error>

impl<T: Decodable> Decodable for Rc<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error>

impl<T: Decodable> Decodable for Vec<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error>

impl Decodable for [u8; 20]

fn decode<D: Decoder>(d: &mut D) -> Result<[u8; 20], D::Error>

impl<T: Decodable + ToOwned> Decodable for Cow<'static, [T]> where
    [T]: ToOwned<Owned = Vec<T>>, 

fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, [T]>, D::Error>

impl<T: Decodable> Decodable for Option<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error>

impl<T1: Decodable, T2: Decodable> Decodable for Result<T1, T2>

fn decode<D: Decoder>(d: &mut D) -> Result<Result<T1, T2>, D::Error>

impl<T0: Decodable, T1: Decodable, T2: Decodable, T3: Decodable, T4: Decodable, T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T1: Decodable, T2: Decodable, T3: Decodable, T4: Decodable, T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T2: Decodable, T3: Decodable, T4: Decodable, T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T3: Decodable, T4: Decodable, T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T4: Decodable, T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T4, T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T4, T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T5: Decodable, T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T5, T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(
    d: &mut D
) -> Result<(T5, T6, T7, T8, T9, T10, T11), D::Error>

impl<T6: Decodable, T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T6, T7, T8, T9, T10, T11)

fn decode<D: Decoder>(d: &mut D) -> Result<(T6, T7, T8, T9, T10, T11), D::Error>

impl<T7: Decodable, T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T7, T8, T9, T10, T11)

fn decode<D: Decoder>(d: &mut D) -> Result<(T7, T8, T9, T10, T11), D::Error>

impl<T8: Decodable, T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T8, T9, T10, T11)

fn decode<D: Decoder>(d: &mut D) -> Result<(T8, T9, T10, T11), D::Error>

impl<T9: Decodable, T10: Decodable, T11: Decodable> Decodable for (T9, T10, T11)

fn decode<D: Decoder>(d: &mut D) -> Result<(T9, T10, T11), D::Error>

impl<T10: Decodable, T11: Decodable> Decodable for (T10, T11)

fn decode<D: Decoder>(d: &mut D) -> Result<(T10, T11), D::Error>

impl<T11: Decodable> Decodable for (T11,)

fn decode<D: Decoder>(d: &mut D) -> Result<(T11,), D::Error>

impl Decodable for PathBuf

fn decode<D: Decoder>(d: &mut D) -> Result<PathBuf, D::Error>

impl<T: Decodable + Copy> Decodable for Cell<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error>

impl<T: Decodable> Decodable for RefCell<T>

fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error>

impl<T: Decodable> Decodable for Arc<T>

fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error>

Loading content...

Implementors

impl<T: UseSpecializedDecodable> Decodable for T

default fn decode<D: Decoder>(d: &mut D) -> Result<T, D::Error>

Loading content...