qualia_core_db/bundle/stream/publish/
context.rs1use 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 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}