use crate::SourceFile;
use crate::provenance::CanonicalDatasetDigests;
use crate::raw::{RawDataset, RawDescriptor, SamplingSchedule};
#[derive(Clone, Debug, PartialEq)]
pub struct RawDatasetSnapshot {
descriptor: RawDescriptor,
sources: Vec<SourceFile>,
sample_normalization: crate::provenance::SampleNormalization,
sampling: Option<SamplingSchedule>,
absolute_origin: Box<[usize]>,
canonical_digests: CanonicalDatasetDigests,
}
impl RawDatasetSnapshot {
pub(crate) fn validate_recorded(
&self,
control: &mut crate::ExecutionContext<'_>,
) -> Result<(), crate::internal::ModelError> {
use crate::internal::ModelError;
let token = Some(control.cancellation());
let descriptor =
crate::canonical_digest::descriptor_digest_controlled(&self.descriptor, token)?;
if self.absolute_origin.as_ref() != self.descriptor.layout().absolute_origin()
|| crate::canonical_digest::raw_binding(
descriptor,
self.canonical_digests.samples(),
self.sampling.as_ref(),
token,
)? != self.canonical_digests
{
return Err(ModelError::DigestMismatch);
}
if let Some(schedule) = &self.sampling {
if schedule.declaration().is_some_and(|d| {
d.indirect_lanes()
!= &self.descriptor.component_lanes()[..self.descriptor.axes().len() - 1]
}) {
return Err(ModelError::Structure);
}
if schedule
.grid()
.iter()
.copied()
.ne(self.descriptor.axes()[..self.descriptor.axes().len() - 1]
.iter()
.map(|a| a.points()))
{
return Err(ModelError::Structure);
}
}
Ok(())
}
pub fn descriptor(&self) -> &RawDescriptor {
&self.descriptor
}
pub fn sources(&self) -> &[SourceFile] {
&self.sources
}
pub fn sample_normalization(&self) -> &crate::provenance::SampleNormalization {
&self.sample_normalization
}
pub fn sampling_schedule(&self) -> Option<&SamplingSchedule> {
self.sampling.as_ref()
}
pub fn absolute_origin(&self) -> &[usize] {
&self.absolute_origin
}
pub fn canonical_digests(&self) -> CanonicalDatasetDigests {
self.canonical_digests
}
}
impl RawDataset {
pub fn snapshot(&self) -> RawDatasetSnapshot {
debug_assert!(self.validate().is_ok());
self.snapshot_with_digests(self.canonical_digests())
}
pub(crate) fn snapshot_with_digests(
&self,
canonical_digests: CanonicalDatasetDigests,
) -> RawDatasetSnapshot {
RawDatasetSnapshot {
descriptor: self.descriptor().clone(),
sources: self.provenance().sources().to_vec(),
sample_normalization: self.provenance().sample_normalization().clone(),
sampling: self.sampling_schedule().cloned(),
absolute_origin: self.data().layout().absolute_origin().into(),
canonical_digests,
}
}
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum ProcessedOrigin {
Library(Box<crate::derivation::LibraryDerivation>),
External(Box<crate::external::ExternalBoundary>),
Imported,
DeclaredRaw {
snapshot: Box<RawDatasetSnapshot>,
axis_lineage: Vec<crate::provenance::InputAxisRef>,
},
DerivedRaw(DerivedRawOrigin),
Unknown,
}
#[derive(Clone, Debug, PartialEq)]
pub struct DerivedRawOrigin {
snapshot: Box<RawDatasetSnapshot>,
axis_lineage: Vec<crate::provenance::InputAxisRef>,
}
impl DerivedRawOrigin {
pub fn snapshot(&self) -> &RawDatasetSnapshot {
&self.snapshot
}
pub fn axis_lineage(&self) -> &[crate::provenance::InputAxisRef] {
&self.axis_lineage
}
pub(crate) fn new(snapshot: RawDatasetSnapshot, rank: usize) -> Self {
Self {
snapshot: Box::new(snapshot),
axis_lineage: (0..rank)
.map(crate::provenance::InputAxisRef::single)
.collect(),
}
}
}
impl DerivedRawOrigin {
#[allow(clippy::type_complexity, clippy::borrowed_box)]
pub(crate) fn model_parts(
&self,
) -> (
&Box<RawDatasetSnapshot>,
&Vec<crate::provenance::InputAxisRef>,
) {
(&self.snapshot, &self.axis_lineage)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
Box<RawDatasetSnapshot>,
Vec<crate::provenance::InputAxisRef>,
),
) -> Result<Self, crate::internal::ModelError> {
let (snapshot, axis_lineage) = parts;
let value = Self {
snapshot,
axis_lineage,
};
Ok(value)
}
}
impl RawDatasetSnapshot {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&RawDescriptor,
&Vec<SourceFile>,
&crate::provenance::SampleNormalization,
&Option<SamplingSchedule>,
&Box<[usize]>,
&CanonicalDatasetDigests,
) {
(
&self.descriptor,
&self.sources,
&self.sample_normalization,
&self.sampling,
&self.absolute_origin,
&self.canonical_digests,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
RawDescriptor,
Vec<SourceFile>,
crate::provenance::SampleNormalization,
Option<SamplingSchedule>,
Box<[usize]>,
CanonicalDatasetDigests,
),
) -> Result<Self, crate::internal::ModelError> {
let (
descriptor,
sources,
sample_normalization,
sampling,
absolute_origin,
canonical_digests,
) = parts;
let value = Self {
descriptor,
sources,
sample_normalization,
sampling,
absolute_origin,
canonical_digests,
};
Ok(value)
}
}