Trait rustc_serialize::serialize::Decodable[−][src]

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

Expand description

Trait for types that can be deserialized

This can be implemented using the Decodable, TyDecodable and MetadataDecodable macros.

Decodable should be used in crates that don’t depend on rustc_middle.
MetadataDecodable is used in rustc_metadata for types that contain rustc_metadata::rmeta::Lazy.
TyDecodable should be used for types that are only serialized in crate metadata or the incremental cache. This is most types in rustc_middle.

Required methods

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

Implementations on Foreign Types

impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]>

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

impl<D: Decoder> Decodable<D> for usize

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

impl<D: Decoder> Decodable<D> for u8

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

impl<D: Decoder> Decodable<D> for u16

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

impl<D: Decoder> Decodable<D> for u32

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

impl<D: Decoder> Decodable<D> for u64

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

impl<D: Decoder> Decodable<D> for u128

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

impl<D: Decoder> Decodable<D> for isize

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

impl<D: Decoder> Decodable<D> for i8

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

impl<D: Decoder> Decodable<D> for i16

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

impl<D: Decoder> Decodable<D> for i32

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

impl<D: Decoder> Decodable<D> for i64

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

impl<D: Decoder> Decodable<D> for i128

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

impl<D: Decoder> Decodable<D> for f32

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

impl<D: Decoder> Decodable<D> for f64

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

impl<D: Decoder> Decodable<D> for bool

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

impl<D: Decoder> Decodable<D> for char

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

impl<D: Decoder> Decodable<D> for !

fn decode(_d: &mut D) -> Result<!, D::Error>

impl<D: Decoder> Decodable<D> for NonZeroU32

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

impl<D: Decoder> Decodable<D> for String

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

impl<D: Decoder> Decodable<D> for ()

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

impl<D: Decoder, T> Decodable<D> for PhantomData<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T>

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

impl<D: Decoder, const N: usize> Decodable<D> for [u8 ; N]

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

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

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<D: Decoder> Decodable<D> for PathBuf

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

impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for RefCell<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<T>

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

impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T>

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

impl<'a> Decodable<Decoder<'a>> for Vec<u8>

fn decode(d: &mut Decoder<'a>) -> Result<Self, String>

Implementors

impl<'a> Decodable<Decoder<'a>> for IntEncodedWithFixedSize