Skip to main content

qualia_core_db/sensing/acquisition/storage/
read.rs

1use super::{values::*,*};
2use crate::{q42::{field_envelope as env,field_semantics as sem},sensing::acquisition as a};
3/// Scratch may change on failure. Every returned Original has been fully verified.
4/// This acquisition-only document reader rejects other profiles rather than guessing.
5pub fn admit<'a,'s>(
6 view:&env::StructuralView<'a>,selected:u32,originals:&'s mut[Option<a::Original<'a>>],
7 scratch:&mut sem::Scratch<'_>,mut shared:sem::Limits,limits:Limits,
8)->Result<Document<'a,'s>,Error>{
9 if view.entry_count()>limits.entries||view.entry_count() as usize>originals.len(){return Err(Error::Scratch);}
10 if selected==0||selected>view.entry_count(){return Err(Error::Reference);}
11 let mut work=limits.work;let mut bytes=0u64;
12 // Reject reference/validity paths that might hash before our aggregate admission.
13 for i in 1..=view.entry_count(){
14  let e=view.entry(i)?;
15  bytes=bytes.checked_add(e.stored_bytes()).ok_or(Error::Overflow)?;
16  if e.mode()!=ORIGINAL_MODE||e.revision()!=1||e.flags()!=0||e.stride()!=1||e.frame_id()!=0{return Err(Error::Unsupported);}
17  let mut found=None;
18  for b in view.blocks(){work=work.checked_sub(1).ok_or(Error::Limit)?;if b.id()==e.descriptor_id(){found=Some(b);break;}}
19  let d=found.ok_or(Error::Reference)?;
20  if d.schema_type()!=3||d.revision()!=1{return Err(Error::Metadata);}
21  absent(d,&[1,2,4,5,6,13,14,15,16])?;
22 }
23 if bytes>limits.source_bytes{return Err(Error::Limit);}
24 // verify_chunk + Original::admit both scan each complete source.
25 work=work.checked_sub(bytes.checked_mul(2).ok_or(Error::Overflow)?).ok_or(Error::Limit)?;
26 for b in view.blocks(){
27  work=work.checked_sub(1).ok_or(Error::Limit)?;
28  if b.schema_type()==6{
29   if field(b,40).is_some(){
30    let n=u64v(b,40)?;if n>limits.events{return Err(Error::Limit);}
31    work=work.checked_sub(n.checked_mul(20).ok_or(Error::Overflow)?).ok_or(Error::Limit)?;
32   }
33  }
34 }
35 shared.work=shared.work.min(work);
36 let admitted=sem::admit_shared(view,&AcquisitionRegistry{limits},scratch,shared)?;
37 let ctx=&admitted.context;
38 let mut uninterpreted_fields=0u32;
39 for b in view.blocks(){let known=match b.schema_type(){6=>Some(schema::VIEW),7=>Some(schema::LINEAGE),_=>None};
40  if let Some(rules)=known{for f in b.fields(){if !rules.iter().any(|r|r.key==f.key()){uninterpreted_fields=uninterpreted_fields.checked_add(1).ok_or(Error::Overflow)?;}}}
41 }
42 for i in 1..=view.entry_count(){
43  let e=ctx.entry(i)?;let d=descriptor(e,ctx)?;
44  let mut views=0;let mut lines=0;
45  for raw in get(d,18)?.value().chunks_exact(4){
46   let b=ctx.block(u32::from_le_bytes(raw.try_into().unwrap()))?;
47   match b.schema_type(){6=>{views+=1;if u32v(b,2)?!=i{return Err(Error::Reference);}},7=>{lines+=1;if u32v(b,1)?!=i{return Err(Error::Reference);}},_=>return Err(Error::Unsupported)}
48  }
49  if views>1||lines>1{return Err(Error::Metadata);}
50  // No interpreted numeric payload is scanned until the complete index/metadata passed.
51 }
52 let e=ctx.entry(selected)?;let d=descriptor(e,ctx)?;
53 let mut declaration=None;let mut line=None;
54 for raw in get(d,18)?.value().chunks_exact(4){
55  let b=ctx.block(u32::from_le_bytes(raw.try_into().unwrap()))?;
56  match b.schema_type(){6=>declaration=Some((b,registry::declaration(b,ctx,limits)?)),7=>line=Some(lineage::Lineage{block:b}),_=>return Err(Error::Unsupported)}
57 }
58 let (block,decl)=declaration.ok_or(Error::Unsupported)?;
59 // Verify every original, including lineage inputs, before any view is released.
60 for i in 1..=view.entry_count(){
61  let payload=view.verify_chunk(i)?;
62  originals[i as usize-1]=Some(a::Original::admit(payload,usize::try_from(limits.source_bytes).map_err(|_|Error::Overflow)?)?);
63 }
64 let original=originals[decl.entry as usize-1].ok_or(Error::Reference)?;
65 let region=original.region(decl.offset,decl.bytes)?;
66 let output=match decl.kind {
67  1=>View::Tensor(a::TensorView::admit(region,decl.layout.ok_or(Error::Metadata)?,decl.context,decl.clock,decl.axes)?),
68  2=>View::Events{view:a::EventView::admit(region,u32v(block,41)?,layout::byte_order(block)?,
69    if u32v(block,42)?==0{a::EventOrdering::AcquisitionOrder}else{a::EventOrdering::NondecreasingTick},
70    decl.clock.ok_or(Error::Metadata)?,decl.context,decl.events)?,axes:decl.axes},
71  3=>{
72   let tensor=a::TensorView::admit(region,decl.layout.ok_or(Error::Metadata)?,decl.context,None,decl.axes)?;
73   View::Correlation(a::CorrelationView::admit(tensor,decl.clock.ok_or(Error::Metadata)?,i64v(block,43)?,i64v(block,44)?,layout::product(block)?,layout::normalization(block)?)?)
74  },_=>return Err(Error::Unsupported)
75 };
76 Ok(Document{view:output,lineage:line,metadata_bytes:view.metadata_bytes(),uninterpreted_blocks:admitted.preserved_unknown_blocks,uninterpreted_fields,originals:&originals[..view.entry_count() as usize]})
77}