summaryrefslogtreecommitdiffstats
path: root/compiler/rustc_serialize/src/collection_impls.rs
diff options
context:
space:
mode:
Diffstat (limited to 'compiler/rustc_serialize/src/collection_impls.rs')
-rw-r--r--compiler/rustc_serialize/src/collection_impls.rs279
1 files changed, 0 insertions, 279 deletions
diff --git a/compiler/rustc_serialize/src/collection_impls.rs b/compiler/rustc_serialize/src/collection_impls.rs
deleted file mode 100644
index 8f8c50411..000000000
--- a/compiler/rustc_serialize/src/collection_impls.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-//! Implementations of serialization for structures found in liballoc
-
-use crate::{Decodable, Decoder, Encodable, Encoder};
-use smallvec::{Array, SmallVec};
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
-use std::hash::{BuildHasher, Hash};
-use std::rc::Rc;
-use std::sync::Arc;
-use thin_vec::ThinVec;
-
-impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> {
- fn encode(&self, s: &mut S) {
- let slice: &[A::Item] = self;
- slice.encode(s);
- }
-}
-
-impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
- fn decode(d: &mut D) -> SmallVec<A> {
- let len = d.read_usize();
- (0..len).map(|_| Decodable::decode(d)).collect()
- }
-}
-
-impl<S: Encoder, T: Encodable<S>> Encodable<S> for ThinVec<T> {
- fn encode(&self, s: &mut S) {
- self.as_slice().encode(s);
- }
-}
-
-impl<D: Decoder, T: Decodable<D>> Decodable<D> for ThinVec<T> {
- fn decode(d: &mut D) -> ThinVec<T> {
- let len = d.read_usize();
- (0..len).map(|_| Decodable::decode(d)).collect()
- }
-}
-
-impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
- fn encode(&self, s: &mut S) {
- s.emit_usize(self.len());
- for e in self.iter() {
- e.encode(s);
- }
- }
-}
-
-impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
- fn decode(d: &mut D) -> LinkedList<T> {
- let len = d.read_usize();
- (0..len).map(|_| Decodable::decode(d)).collect()
- }
-}
-
-impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
- fn encode(&self, s: &mut S) {
- s.emit_usize(self.len());
- for e in self.iter() {
- e.encode(s);
- }
- }
-}
-
-impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
- fn decode(d: &mut D) -> VecDeque<T> {
- let len = d.read_usize();
- (0..len).map(|_| Decodable::decode(d)).collect()
- }
-}
-
-impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V>
-where
- K: Encodable<S> + PartialEq + Ord,
- V: Encodable<S>,
-{
- fn encode(&self, e: &mut S) {
- e.emit_usize(self.len());
- for (key, val) in self.iter() {
- key.encode(e);
- val.encode(e);
- }
- }
-}
-
-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) -> BTreeMap<K, V> {
- let len = d.read_usize();
- let mut map = BTreeMap::new();
- for _ in 0..len {
- let key = Decodable::decode(d);
- let val = Decodable::decode(d);
- map.insert(key, val);
- }
- map
- }
-}
-
-impl<S: Encoder, T> Encodable<S> for BTreeSet<T>
-where
- T: Encodable<S> + PartialEq + Ord,
-{
- fn encode(&self, s: &mut S) {
- s.emit_usize(self.len());
- for e in self.iter() {
- e.encode(s);
- }
- }
-}
-
-impl<D: Decoder, T> Decodable<D> for BTreeSet<T>
-where
- T: Decodable<D> + PartialEq + Ord,
-{
- fn decode(d: &mut D) -> BTreeSet<T> {
- let len = d.read_usize();
- let mut set = BTreeSet::new();
- for _ in 0..len {
- set.insert(Decodable::decode(d));
- }
- set
- }
-}
-
-impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S>
-where
- K: Encodable<E> + Eq,
- V: Encodable<E>,
- S: BuildHasher,
-{
- fn encode(&self, e: &mut E) {
- e.emit_usize(self.len());
- for (key, val) in self.iter() {
- key.encode(e);
- val.encode(e);
- }
- }
-}
-
-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) -> HashMap<K, V, S> {
- let len = d.read_usize();
- let state = Default::default();
- let mut map = HashMap::with_capacity_and_hasher(len, state);
- for _ in 0..len {
- let key = Decodable::decode(d);
- let val = Decodable::decode(d);
- map.insert(key, val);
- }
- map
- }
-}
-
-impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S>
-where
- T: Encodable<E> + Eq,
- S: BuildHasher,
-{
- fn encode(&self, s: &mut E) {
- s.emit_usize(self.len());
- for e in self.iter() {
- e.encode(s);
- }
- }
-}
-
-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) -> HashSet<T, S> {
- let len = d.read_usize();
- let state = Default::default();
- let mut set = HashSet::with_capacity_and_hasher(len, state);
- for _ in 0..len {
- set.insert(Decodable::decode(d));
- }
- set
- }
-}
-
-impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S>
-where
- K: Encodable<E> + Hash + Eq,
- V: Encodable<E>,
- S: BuildHasher,
-{
- fn encode(&self, e: &mut E) {
- e.emit_usize(self.len());
- for (key, val) in self.iter() {
- key.encode(e);
- val.encode(e);
- }
- }
-}
-
-impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S>
-where
- K: Decodable<D> + Hash + Eq,
- V: Decodable<D>,
- S: BuildHasher + Default,
-{
- fn decode(d: &mut D) -> indexmap::IndexMap<K, V, S> {
- let len = d.read_usize();
- let state = Default::default();
- let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
- for _ in 0..len {
- let key = Decodable::decode(d);
- let val = Decodable::decode(d);
- map.insert(key, val);
- }
- map
- }
-}
-
-impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S>
-where
- T: Encodable<E> + Hash + Eq,
- S: BuildHasher,
-{
- fn encode(&self, s: &mut E) {
- s.emit_usize(self.len());
- for e in self.iter() {
- e.encode(s);
- }
- }
-}
-
-impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S>
-where
- T: Decodable<D> + Hash + Eq,
- S: BuildHasher + Default,
-{
- fn decode(d: &mut D) -> indexmap::IndexSet<T, S> {
- let len = d.read_usize();
- let state = Default::default();
- let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
- for _ in 0..len {
- set.insert(Decodable::decode(d));
- }
- set
- }
-}
-
-impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> {
- fn encode(&self, s: &mut E) {
- let slice: &[T] = self;
- slice.encode(s);
- }
-}
-
-impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]> {
- fn decode(d: &mut D) -> Rc<[T]> {
- let vec: Vec<T> = Decodable::decode(d);
- vec.into()
- }
-}
-
-impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> {
- fn encode(&self, s: &mut E) {
- let slice: &[T] = self;
- slice.encode(s);
- }
-}
-
-impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]> {
- fn decode(d: &mut D) -> Arc<[T]> {
- let vec: Vec<T> = Decodable::decode(d);
- vec.into()
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-20 16:32:39 +0000