let _i: SerializedDepNodeIndex = fingerprints.push(fingerprint);
debug_assert_eq!(_i.index(), _index);
- d.read_seq(|d, len| {
- let start = edge_list_data.len().try_into().unwrap();
- for _ in 0..len {
- let edge = Decodable::decode(d);
- edge_list_data.push(edge);
- }
- let end = edge_list_data.len().try_into().unwrap();
- let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
- debug_assert_eq!(_i.index(), _index);
- })
+ // Deserialize edges -- sequence of DepNodeIndex
+ let len = d.read_usize();
+ let start = edge_list_data.len().try_into().unwrap();
+ for _ in 0..len {
+ let edge = Decodable::decode(d);
+ edge_list_data.push(edge);
+ }
+ let end = edge_list_data.len().try_into().unwrap();
+ let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
+ debug_assert_eq!(_i.index(), _index);
}
let index: FxHashMap<_, _> =
impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
fn decode(d: &mut D) -> SmallVec<A> {
- d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
+ let len = d.read_usize();
+ (0..len).map(|_| Decodable::decode(d)).collect()
}
}
impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
fn decode(d: &mut D) -> LinkedList<T> {
- d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
+ let len = d.read_usize();
+ (0..len).map(|_| Decodable::decode(d)).collect()
}
}
impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
fn decode(d: &mut D) -> VecDeque<T> {
- d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
+ let len = d.read_usize();
+ (0..len).map(|_| Decodable::decode(d)).collect()
}
}
T: Decodable<D> + PartialEq + Ord,
{
fn decode(d: &mut D) -> BTreeSet<T> {
- d.read_seq(|d, len| {
- let mut set = BTreeSet::new();
- for _ in 0..len {
- set.insert(Decodable::decode(d));
- }
- set
- })
+ let len = d.read_usize();
+ let mut set = BTreeSet::new();
+ for _ in 0..len {
+ set.insert(Decodable::decode(d));
+ }
+ set
}
}
S: BuildHasher + Default,
{
fn decode(d: &mut D) -> HashSet<T, S> {
- d.read_seq(|d, len| {
- let state = Default::default();
- let mut set = HashSet::with_capacity_and_hasher(len, state);
- for _ in 0..len {
- set.insert(Decodable::decode(d));
- }
- set
- })
+ 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
}
}
S: BuildHasher + Default,
{
fn decode(d: &mut D) -> indexmap::IndexSet<T, S> {
- d.read_seq(|d, len| {
- 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
- })
+ 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
}
}
fn read_str(&mut self) -> Cow<'_, str>;
fn read_raw_bytes_into(&mut self, s: &mut [u8]);
- fn read_seq<T, F>(&mut self, f: F) -> T
- where
- F: FnOnce(&mut Self, usize) -> T,
- {
- let len = self.read_usize();
- f(self, len)
- }
-
fn read_map<T, F>(&mut self, f: F) -> T
where
F: FnOnce(&mut Self, usize) -> T,
impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
default fn decode(d: &mut D) -> Vec<T> {
- d.read_seq(|d, len| {
- // SAFETY: we set the capacity in advance, only write elements, and
- // only set the length at the end once the writing has succeeded.
- let mut vec = Vec::with_capacity(len);
- unsafe {
- let ptr: *mut T = vec.as_mut_ptr();
- for i in 0..len {
- std::ptr::write(ptr.offset(i as isize), Decodable::decode(d));
- }
- vec.set_len(len);
+ let len = d.read_usize();
+ // SAFETY: we set the capacity in advance, only write elements, and
+ // only set the length at the end once the writing has succeeded.
+ let mut vec = Vec::with_capacity(len);
+ unsafe {
+ let ptr: *mut T = vec.as_mut_ptr();
+ for i in 0..len {
+ std::ptr::write(ptr.offset(i as isize), Decodable::decode(d));
}
- vec
- })
+ vec.set_len(len);
+ }
+ vec
}
}
impl<D: Decoder, const N: usize> Decodable<D> for [u8; N] {
fn decode(d: &mut D) -> [u8; N] {
- d.read_seq(|d, len| {
- assert!(len == N);
- let mut v = [0u8; N];
- for i in 0..len {
- v[i] = Decodable::decode(d);
- }
- v
- })
+ let len = d.read_usize();
+ assert!(len == N);
+ let mut v = [0u8; N];
+ for i in 0..len {
+ v[i] = Decodable::decode(d);
+ }
+ v
}
}