State index: each file's deferred history decoded only when used (refs #41) 3f1b8fe25ec9

        #[cfg(test)]

        assert_eq!(

            State::read_index(&body).ok().and_then(|s| s.write_index()),

            Some(body.clone()),

            "a state index reads back as written"

        );

///

/// Read from a state index, it stays encoded until first used: a command

/// that builds a few files decodes only their histories.

    body: std::sync::OnceLock<DeferredBody>,

    /// The body as the index encodes it, decoded into `body` on first use.

    raw: Option<(Arc<[u8]>, std::ops::Range<usize>)>,

    /// Its graph key, once worked out (or read from an index); reset by

    /// any edit added.

    key: std::sync::OnceLock<[u8; 32]>,

}

#[derive(Clone, Default)]

struct DeferredBody {

}

impl Deferred {

    fn from_body(body: DeferredBody) -> Deferred {

        Deferred {

            body: std::sync::OnceLock::from(body),

            ..Deferred::default()

        }

    }

    fn body(&self) -> &DeferredBody {

        self.body.get_or_init(|| match &self.raw {

            // The index was checked against its hash when read, and was

            // written by `write_index`: it decodes.

            Some((bytes, range)) => State::read_deferred_body(&bytes[range.clone()])

                .expect("a state index checked by its hash decodes"),

            None => DeferredBody::default(),

        })

    }

    fn body_mut(&mut self) -> &mut DeferredBody {

        self.body();

        self.raw = None;

        self.body.get_mut().expect("decoded above")

    }

    fn into_body(mut self) -> DeferredBody {

        self.body();

        self.body.take().expect("decoded above")

    }

    const INDEX_MAGIC: &'static [u8] = b"oxy state index 2\n";

            let mut h = blake3::Hasher::new();

            h.update(b"oxy graph key 1\0");

            h.update(&n.0);

            w.fixed(d.key.get_or_init(|| d.graph_key(h)));

            // Unchanged since read (a change clears `raw`): copied as it is.

            if let Some((bytes, range)) = &d.raw {

                w.bytes(&bytes[range.clone()]);

                continue;

            }

            let d = d.body();

            let outer_w = std::mem::take(&mut w);

            let body = std::mem::replace(&mut w, outer_w);

            w.bytes(&body.0);

    /// The deferred block: each node with its graph key and its body,

    /// left encoded (see [`Deferred`]).

        let all: Arc<[u8]> = Arc::from(bytes);

        let mut r = Reader::new(bytes);

        let mut deferred: HashMap<NodeId, Arc<Deferred>> = HashMap::new();

        let n = r.count()?;

        deferred.reserve(n);

        for _ in 0..n {

            let id = NodeId(r.fixed::<16>()?);

            let key = r.fixed::<32>()?;

            let body = r.bytes()?;

            let start = body.as_ptr() as usize - bytes.as_ptr() as usize;

            let d = Deferred {

                raw: Some((all.clone(), start..start + body.len())),

                key: std::sync::OnceLock::from(key),

                ..Deferred::default()

            };

            deferred.insert(id, Arc::new(d));

        }

        if !r.at_end() {

            return Err(ObjectError::Schema("state index: trailing bytes".into()));

        }

        Ok(deferred)

    }

    /// One node's deferred history as the index encodes it.

    fn read_deferred_body(bytes: &[u8]) -> Result<DeferredBody, ObjectError> {

        use crate::flat::Reader;

        let base = match r.u8()? {

            0 => None,

            1 => Some(DeferredBase::Blob(r.object()?)),

            _ => Some(DeferredBase::Inline(cbor::decode(r.bytes()?)?)),

        };

        let mut edits = Vec::new();

        for _ in 0..r.count()? {

            let c = r.object()?;

            let mut es = Vec::new();

                es.push(match r.u8()? {

                    0 => Edit::Insert {

                        node: node(&mut r)?,

                        after: atom(&mut r)?,

                        before: atom(&mut r)?,

                        lines: crate::lines::Lines::default(),

                    1 => {

                        let node = node(&mut r)?;

                        let mut atoms = Vec::new();

                        for _ in 0..r.count()? {

                            atoms.push(crate::objects::AtomRange {

                                change: r.object()?,

                                from: r.u32()?,

                                to: r.u32()?,

                            });

                        }

                        Edit::Delete { node, atoms }

                    }

                    _ => return Err(bad("edit")),

            edits.push((c, es));

        }

        let mut texts = Vec::new();

        for _ in 0..r.count()? {

            texts.push(match r.u8()? {

                0 => TextRef::Blob(

                    r.object()?,

                    r.u32()?,

                    match r.u8()? {

                        0 => crate::objects::TextForm::Cbor,

                        1 => crate::objects::TextForm::Raw,

                        _ => crate::objects::TextForm::CborFallback,

                    },

                ),

                _ => TextRef::Inline {

                    change: r.object()?,

                    start: r.u32()?,

                    end: r.u32()?,

                },

            });

            return Err(bad("trailing bytes in a file's history"));

        Ok(DeferredBody { base, edits, texts })

    taken: Vec<(NodeId, Deferred)>,

    let mut taken: Vec<(NodeId, DeferredBody)> =

        taken.into_iter().map(|(n, d)| (n, d.into_body())).collect();

    let mut work: Vec<(NodeId, DeferredBody, Option<Vec<u8>>)> = Vec::with_capacity(taken.len());

        let d = self.body();

                Arc::new(Deferred::from_body(DeferredBody {

                    ..DeferredBody::default()

                })),

                        let b = d.body_mut();

                        b.edits.push((h, edits));

                        b.texts.extend(node_texts);