Skip to main content

qualia_core_db/bundle/stream/publish/
context.rs

1use super::PlainPublisher;
2use crate::bundle::stream::descriptor::*;
3impl PlainPublisher<'_, '_> {
4    pub fn emit_context_page(
5        &mut self,
6        page: usize,
7        out: &mut [u8],
8        framing: &mut [u8],
9        mut sink: impl FnMut(&[u8], PageRef) -> Result<(), DescriptorError>,
10    ) -> Result<usize, DescriptorError> {
11        self.live()?;
12        if self.context_id.is_some() || page != self.context_next || page >= self.page_count() {
13            return Err(DescriptorError::Page);
14        }
15        let first = page * PAGE_ROWS;
16        let count = (self.entry_count() - first).min(PAGE_ROWS);
17        let mut rows = [ContextEntry::EMPTY; PAGE_ROWS];
18        let mut seen = 0;
19        for (i, row) in self.index.entries().skip(first).take(count).enumerate() {
20            let actual = row.map_err(|_| DescriptorError::Source)?;
21            rows[i] = ContextEntry {
22                id: self.assignments[first + i].id,
23                length: actual.length(),
24            };
25            seen += 1;
26        }
27        if seen != count {
28            return Err(DescriptorError::Coverage);
29        }
30        let n = encode_context_page_into(page as u32, first as u32, &rows[..count], out)?;
31        let digest = domain_digest(DigestDomain::ContextPage, &out[..n], framing)?;
32        let used = self.charge(n)?;
33        let reference = PageRef {
34            number: page as u32,
35            first: first as u32,
36            rows: count as u32,
37            encoded_length: n as u32,
38            digest,
39        };
40        self.poisoned = true;
41        sink(&out[..n], reference).map_err(|_| DescriptorError::Sink)?;
42        self.context_refs[page] = reference;
43        self.context_next += 1;
44        self.used = used;
45        self.poisoned = false;
46        Ok(n)
47    }
48    /// Idempotent encoding of the fixed completed context; callbacks are not repeated.
49    pub fn encode_context_root(
50        &mut self,
51        out: &mut [u8],
52        framing: &mut [u8],
53    ) -> Result<usize, DescriptorError> {
54        self.live()?;
55        if self.context_next != self.page_count() {
56            return Err(DescriptorError::Incomplete);
57        }
58        let input = ContextInput {
59            parameters: self.parameters,
60            source: self.source_commit,
61            entries: self.entry_count(),
62            pages: &self.context_refs[..self.page_count()],
63        };
64        let n = encode_context_into(&input, out)?;
65        let digest = domain_digest(DigestDomain::Context, &out[..n], framing)?;
66        if let Some(want) = self.context_id {
67            if digest != want {
68                return Err(DescriptorError::Commitment);
69            }
70        } else {
71            self.used = self.charge(n)?;
72            self.context_id = Some(digest);
73        }
74        Ok(n)
75    }
76}