Read a change's metadata without its operations 4d6c9c1b358c

impl Change {

    /// A change's metadata alone: its tree operations and edits are

    /// stepped over, not decoded. For log, signature checks and walks of

    /// the dependency graph, which read nothing else.

    pub fn decode_meta(bytes: &[u8]) -> Result<crate::state::ChangeMeta, ObjectError> {

        let mut c = cbor::Cursor::new(bytes);

        let (major, n) = c.head()?;

        if major != 5 {

            return schema("change: expected map");

        }

        let mut fields = Map::new();

        let mut last: Option<u64> = None;

        for _ in 0..n {

            let k = map_key(&mut c, &mut last)?;

            if k == 6 || k == 7 {

                c.skip()?;

                fields.insert(k, Value::Array(Vec::new()));

            } else {

                fields.insert(k, c.value()?);

            }

        }

        if !c.at_end() {

            return Err(ObjectError::Cbor(cbor::CborError::TrailingBytes));

        }

        Ok(crate::state::ChangeMeta::of(&Change::from_value(

            &Value::Map(fields),

        )?))

    }

}

    }

    #[test]

    fn metadata_reads_without_the_operations() {

        let c = with_insert(sample_change(), big_lines(500));

        let (bytes, _) = c.encode_parts();

        let m = Change::decode_meta(&bytes).unwrap();

        assert_eq!(m, crate::state::ChangeMeta::of(&c));

        // A shallow clone knows changes beyond its boundary from a

        // checkpoint's metadata only: its log comes from the state.

        let metas = if self.is_shallow() {

            self.load_state_history(&all)?

                .changes()

                .map(|(h, m)| (*h, m.clone()))

                .collect()

        } else {

            self.metas_of(&all)?

        };

        for (h, meta) in metas {

                hash: h,

                change: meta,

                is_working_copy: h == wc_hash,

                is_head: head_set.contains(&h),

        // The log needs change metadata only: neither graphs nor the tree.

        if self.is_shallow() {

            return Ok(self.log_of(&self.load_state_history(heads)?));

        }

        let metas = self.metas_of(heads)?;

        let depended: BTreeSet<ChangeHash> = metas

            .iter()

            .flat_map(|(_, m)| m.deps.iter().copied())

            .collect();

        let mut entries: Vec<LogEntry> = metas

            .into_iter()

            .map(|(h, meta)| LogEntry {

                hash: h,

                is_head: !depended.contains(&h),

                change: meta,

                is_working_copy: false,

            })

            .collect();

        entries.sort_by(|a, b| b.change.hlc.cmp(&a.change.hlc).then(b.hash.cmp(&a.hash)));

        Ok(entries)

    }

    /// Every change of the state with these heads and its metadata, read

    /// without its operations ([`Store::get_change_meta`]). A change beyond

    /// a shallow clone's boundary is left out.

    pub fn metas_of(

        &self,

        heads: &[ChangeHash],

    ) -> Result<Vec<(ChangeHash, crate::state::ChangeMeta)>> {

        let boundary = self.boundary();

        let mut seen: HashSet<ChangeHash> = HashSet::new();

        let mut stack: Vec<ChangeHash> = heads.to_vec();

        let mut out = Vec::new();

        while let Some(h) = stack.pop() {

            if !seen.insert(h) {

                continue;

            }

            let meta = match self.store.get_change_meta(&h) {

                Ok(m) => m,

                Err(crate::store::StoreError::NotFound(_)) if boundary.contains(&h) => continue,

                Err(e) => return Err(e.into()),

            };

            stack.extend(meta.deps.iter().copied());

            out.push((h, meta));

        }

        Ok(out)

        let bytes = self.get_typed(r, ObjectType::Change)?;

        Change::decode_meta(&bytes).map_err(|e| StoreError::Corrupt(*r, e.to_string()))