qualia_core_db/sensing/acquisition/storage/
registry.rs1use super::*;
2use super::values::*;
3use crate::{q42::{field_envelope::Block,field_semantics::{self as sem,DomainRegistry,FieldRule}},sensing::acquisition as a};
4#[derive(Clone,Copy,Debug)]
5pub struct AcquisitionRegistry {pub limits:Limits}
6impl DomainRegistry for AcquisitionRegistry {
7 fn rules(&self,s:u16,v:u16)->Option<&'static[FieldRule]>{if v!=1{return None;}match s{6=>Some(schema::VIEW),7=>Some(schema::LINEAGE),_=>None}}
8 fn validate_block(&self,b:Block<'_>,ctx:&sem::Context<'_,'_>)->Result<(),sem::Error>{
9 let result=(||->Result<(),Error>{
10 ctx.charge_work((b.fields().count() as u64).checked_mul(128).ok_or(Error::Overflow)?)?;
11 let rules=self.rules(b.schema_type(),1).ok_or(Error::Unsupported)?;
12 for f in b.fields(){if f.flags()&1==0 && rules.iter().any(|r|r.key==f.key()){return Err(Error::Metadata);}}
13 match b.schema_type(){6=>{declaration(b,ctx,self.limits)?;},7=>lineage::validate(b,ctx,self.limits)?,_=>return Err(Error::Unsupported)}
14 Ok(())
15 })();
16 result.map_err(|e|match e{Error::Semantic(s)=>s,Error::Limit=>sem::Error::Limit,Error::Unsupported=>sem::Error::UnsupportedDomain,_=>sem::Error::Value})
17 }
18}
19pub(super) fn attached<'a>(ctx:&sem::Context<'_,'a>,entry:u32,id:u32)->Result<Block<'a>,Error>{
20 let d=descriptor(ctx.entry(entry)?,ctx)?;
21 let mut count=0;
22 for bytes in get(d,18)?.value().chunks_exact(4){ctx.charge_work(1)?;if u32::from_le_bytes(bytes.try_into().unwrap())==id{count+=1;}}
23 if count!=1{return Err(Error::Reference);}Ok(d)
24}
25#[derive(Clone,Copy)]
26pub(super) struct Declaration {
27 pub kind:u32,pub entry:u32,pub offset:usize,pub bytes:usize,pub context:a::Context,pub axes:a::SignalAxes,
28 pub clock:Option<a::Clock>,pub layout:Option<a::Layout>,pub events:usize,
29}
30pub(super) fn declaration<'a>(b:Block<'a>,ctx:&sem::Context<'_,'a>,limits:Limits)->Result<Declaration,Error>{
31 let entry=u32v(b,2)?;let e=ctx.entry(entry)?;attached(ctx,entry,b.id())?;
32 if digest(b,3)?.as_slice()!=e.digest(){return Err(Error::Reference);}
33 let offset=usize::try_from(u64v(b,4)?).map_err(|_|Error::Overflow)?;
34 let bytes=usize::try_from(u64v(b,5)?).map_err(|_|Error::Overflow)?;
35 if offset.checked_add(bytes).ok_or(Error::Overflow)? as u64>e.decoded_bytes(){return Err(Error::Shape);}
36 let context=context::context(b)?;let axes=context::axes(b)?;let clock=context::clock(b,ctx)?;
37 let kind=u32v(b,1)?;let mut layout=None;let mut events=0usize;
38 match kind{
39 1|3=>{
40 absent(b,&[40,41,42])?;
41 let l=layout::layout(b)?;if l.span()?!=bytes{return Err(Error::Shape);}
42 if !l.encoding.complex()&&(axes.complex_convention.is_some()||axes.phase_origin.is_some()){return Err(Error::Metadata);}
43 if kind==1{
44 absent(b,&[43,44,45,46,47,48,49])?;
45 if let Some(c)=clock{
46 let axis=l.axes[..usize::from(l.rank)].iter().position(|x|*x==a::Axis::Sample).ok_or(Error::Shape)?;
47 c.time_at(u64::from(l.extents[axis]-1))?;
48 }
49 }else{
50 clock.ok_or(Error::Metadata)?;
51 if l.rank!=3||l.axes[..3]!=[a::Axis::Lag,a::Axis::LeftChannel,a::Axis::RightChannel]||!l.encoding.complex(){return Err(Error::Shape);}
52 let step=i64v(b,44)?;if step==0{return Err(Error::Shape);}
53 step.checked_mul(i64::from(l.extents[0]-1)).and_then(|x|i64v(b,43).ok().and_then(|first|first.checked_add(x))).ok_or(Error::Overflow)?;
54 layout::product(b)?;layout::normalization(b)?;
55 }
56 layout=Some(l);
57 },
58 2=>{
59 absent(b,&[10,12,13,14,15,16,17,18,19,37,38,39,43,44,45,46,47,48,49])?;
60 layout::byte_order(b)?;clock.ok_or(Error::Metadata)?;
61 let n=u64v(b,40)?;if n>limits.events{return Err(Error::Limit);}
62 if n.checked_mul(20).ok_or(Error::Overflow)?!=bytes as u64||u32v(b,41)?==0||u32v(b,42)?>1{return Err(Error::Shape);}
63 events=usize::try_from(n).map_err(|_|Error::Overflow)?;
64 },
65 _=>return Err(Error::Unsupported)
66 }
67 Ok(Declaration{kind,entry,offset,bytes,context,axes,clock,layout,events})
68}