Skip to main content

qualia_core_db/sensing/acquisition/storage/
lineage.rs

1use super::{values::*,*};
2use crate::{q42::{field_envelope::Block,field_semantics::Context},sensing::acquisition as a};
3/// Immutable declared lineage after graph, full source and field admission.
4#[derive(Clone,Copy,Debug)]
5pub struct Lineage<'a>{pub(super) block:Block<'a>}
6impl Lineage<'_> {
7 pub fn output_entry(self)->u32{u32v(self.block,1).unwrap()}
8 pub fn output_digest(self)->[u8;32]{digest(self.block,2).unwrap()}
9 pub fn algorithm(self)->a::ArtifactLink{a::ArtifactLink{digest:digest(self.block,3).unwrap(),identifier:crate::sensing::SemanticId::new(u64v(self.block,4).unwrap()).unwrap()}}
10 pub fn parameters(self)->a::ArtifactLink{a::ArtifactLink{digest:digest(self.block,5).unwrap(),identifier:crate::sensing::SemanticId::new(u64v(self.block,6).unwrap()).unwrap()}}
11 pub fn inputs(self)->usize{get(self.block,7).unwrap().element_count() as usize}
12 pub fn input_entry(self,index:usize)->Result<u32,Error>{if index>=self.inputs(){return Err(Error::Reference);}Ok(u32_at(get(self.block,7)?.value(),index))}
13 pub fn input_digest(self,index:usize)->Result<[u8;32],Error>{if index>=self.inputs(){return Err(Error::Reference);}Ok(get(self.block,8)?.value()[index*32..index*32+32].try_into().unwrap())}
14 pub fn losses(self)->usize{get(self.block,9).unwrap().element_count() as usize}
15 pub fn loss(self,index:usize)->Result<a::Loss,Error>{
16  if index>=self.losses(){return Err(Error::Reference);}
17  Ok(match u32_at(get(self.block,9)?.value(),index){
18   0=>a::Loss::NoneDeclared,1=>a::Loss::Quantization,2=>a::Loss::Resampling,3=>a::Loss::PhaseDiscarded,4=>a::Loss::ChannelReduction,
19   5=>a::Loss::EventAggregation,6=>a::Loss::Clipping,7=>a::Loss::Windowing,8=>a::Loss::BandSelection,
20   255=>{
21    let positions=get(self.block,10)?.value();let n=positions.chunks_exact(4).position(|x|u32::from_le_bytes(x.try_into().unwrap()) as usize==index).ok_or(Error::Reference)?;
22    a::Loss::Registered(a::ArtifactLink{digest:get(self.block,12)?.value()[n*32..n*32+32].try_into().unwrap(),
23       identifier:crate::sensing::SemanticId::new(u64_at(get(self.block,11)?.value(),n)).map_err(|_|Error::Metadata)?})
24   },_=>return Err(Error::Unsupported)})
25 }
26}
27pub(super) fn validate(b:Block<'_>,ctx:&Context<'_,'_>,limits:Limits)->Result<(),Error>{
28 let output=u32v(b,1)?;let d=registry::attached(ctx,output,b.id())?;
29 if digest(b,2)?.as_slice()!=ctx.entry(output)?.digest(){return Err(Error::Reference);}
30 context::link(b,3)?.ok_or(Error::Metadata)?.validate()?;
31 context::link(b,5)?.ok_or(Error::Metadata)?.validate()?;
32 let inputs=get(b,7)?;let n=inputs.element_count() as usize;
33 let losses=get(b,9)?.element_count() as usize;
34 if n==0||losses==0||n>limits.links||losses>limits.links{return Err(Error::Limit);}
35 ctx.charge_work((n as u64).checked_mul(64).and_then(|x|x.checked_add(losses as u64*8)).ok_or(Error::Overflow)?)?;
36 if get(b,8)?.value().len()!=n.checked_mul(32).ok_or(Error::Overflow)?||get(d,17)?.value()!=inputs.value(){return Err(Error::Reference);}
37 let p=ctx.require_schema(u32v(d,3)?,4)?;
38 if u32v(p,1)?!=2||get(p,2)?.value()!=get(b,8)?.value(){return Err(Error::Reference);}
39 for (i,raw) in inputs.value().chunks_exact(4).enumerate(){
40  let id=u32::from_le_bytes(raw.try_into().unwrap());descriptor(ctx.entry(id)?,ctx)?;
41  if id==output||ctx.entry(id)?.digest()!=&get(b,8)?.value()[i*32..i*32+32]{return Err(Error::Reference);}
42 }
43 let line=Lineage{block:b};let mut registered=0;
44 for i in 0..losses{
45  match u32_at(get(b,9)?.value(),i){0 if losses==1=>{},1..=8=>{},255=>registered+=1,_=>return Err(Error::Metadata)}
46 }
47 if registered==0{absent(b,&[10,11,12])?;}else{
48  if !present(b,&[10,11,12])?||get(b,10)?.element_count() as usize!=registered
49   ||get(b,11)?.element_count() as usize!=registered||get(b,12)?.value().len()!=registered.checked_mul(32).ok_or(Error::Overflow)?{return Err(Error::Metadata);}
50  let mut prior=None;for raw in get(b,10)?.value().chunks_exact(4){
51   let i=u32::from_le_bytes(raw.try_into().unwrap()) as usize;
52   if i>=losses||prior.is_some_and(|p|p>=i)||u32_at(get(b,9)?.value(),i)!=255{return Err(Error::Metadata);}prior=Some(i);
53   line.loss(i)?;
54  }
55 }
56 Ok(())
57}
58
59/// Canonical schema7 encoding, bounded by writer MAX_WRITER_LINKS.
60pub(super) fn encode(d:a::Derivation<'_>,inputs:&[u32],hashes:&[u8],out:&mut[u8],cursor:&mut usize,limits:crate::q42::field_envelope::Limits)->Result<(),Error>{
61 use crate::q42::field_envelope::FieldValue as F;
62 use super::write_metadata::{field as f,block};
63 let output=[1u32];let od=d.output().digest();let algorithm=d.algorithm();let parameters=d.parameters();
64 let aid=[algorithm.identifier.value().ok_or(Error::Metadata)?];let pid=[parameters.identifier.value().ok_or(Error::Metadata)?];
65 let mut codes=[0u32;super::write::MAX_WRITER_LINKS];let mut positions=[0u32;super::write::MAX_WRITER_LINKS];
66 let mut ids=[0u64;super::write::MAX_WRITER_LINKS];let mut digests=[[0u8;32];super::write::MAX_WRITER_LINKS];let mut n=0;
67 for (i,loss) in d.losses().iter().enumerate(){
68  codes[i]=match loss{a::Loss::NoneDeclared=>0,a::Loss::Quantization=>1,a::Loss::Resampling=>2,a::Loss::PhaseDiscarded=>3,a::Loss::ChannelReduction=>4,
69   a::Loss::EventAggregation=>5,a::Loss::Clipping=>6,a::Loss::Windowing=>7,a::Loss::BandSelection=>8,
70   a::Loss::Registered(r)=>{positions[n]=i as u32;ids[n]=r.identifier.value().ok_or(Error::Metadata)?;digests[n]=r.digest;n+=1;255}};
71 }
72 let fields=[f(1,F::EntryRefs(&output)),f(2,F::Bytes(&od)),f(3,F::Bytes(&algorithm.digest)),f(4,F::U64(&aid)),
73  f(5,F::Bytes(&parameters.digest)),f(6,F::U64(&pid)),f(7,F::EntryRefs(inputs)),f(8,F::Bytes(hashes)),
74  f(9,F::U32(&codes[..d.losses().len()])),f(10,F::U32(&positions[..n])),f(11,F::U64(&ids[..n])),f(12,F::Bytes(digests[..n].as_flattened()))];
75 block(out,cursor,5,7,&fields[..if n==0{9}else{12}],limits)
76}