use crate::processed::model::ProcessedDescriptor;
use crate::processing::contracts::operation::AttemptFailure;
use crate::processing::contracts::operation::OperationTarget;
use crate::processing::contracts::operation::ProcessingDiagnostic;
use crate::processing::contracts::operation::ProcessingOperation;
use crate::processing::contracts::operation::ProcessingRequest;
use crate::processing::contracts::operation::ResolvedOperation;
use super::algorithm_version;
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum ProcessingRecord {
#[non_exhaustive]
Attempted {
requested: ProcessingRequest,
failure: AttemptFailure,
diagnostics: Vec<ProcessingDiagnostic>,
},
#[non_exhaustive]
Applied {
requested: ProcessingRequest,
resolved: Box<ResolvedOperation>,
input_descriptor: ProcessedDescriptor,
output_descriptor: ProcessedDescriptor,
algorithm_version: &'static str,
accumulation_order: Option<ComponentAccumulationOrder>,
diagnostics: Vec<ProcessingDiagnostic>,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ComponentAccumulationOrder {
LaneAscending,
}
impl ProcessingRecord {
pub fn target(&self) -> OperationTarget {
self.requested().target()
}
pub fn requested(&self) -> &ProcessingRequest {
match self {
Self::Attempted { requested, .. } | Self::Applied { requested, .. } => requested,
}
}
pub fn resolved(&self) -> Option<&ResolvedOperation> {
match self {
Self::Applied { resolved, .. } => Some(resolved),
Self::Attempted { .. } => None,
}
}
pub fn failure(&self) -> Option<AttemptFailure> {
match self {
Self::Attempted { failure, .. } => Some(*failure),
Self::Applied { .. } => None,
}
}
pub fn diagnostics(&self) -> &[ProcessingDiagnostic] {
match self {
Self::Attempted { diagnostics, .. } | Self::Applied { diagnostics, .. } => diagnostics,
}
}
pub fn descriptor_transition(&self) -> Option<(&ProcessedDescriptor, &ProcessedDescriptor)> {
match self {
Self::Applied {
input_descriptor,
output_descriptor,
..
} => Some((input_descriptor, output_descriptor)),
Self::Attempted { .. } => None,
}
}
pub fn algorithm_version(&self) -> Option<&'static str> {
match self {
Self::Applied {
algorithm_version, ..
} => Some(*algorithm_version),
_ => None,
}
}
pub(crate) fn applied(
requested: impl Into<ProcessingRequest>,
resolved: ResolvedOperation,
input_descriptor: ProcessedDescriptor,
output_descriptor: ProcessedDescriptor,
diagnostics: Vec<ProcessingDiagnostic>,
) -> Self {
let requested = requested.into();
let algorithm_version = algorithm_version(&requested);
let accumulation_order = matches!(
requested,
ProcessingRequest::Explicit(ProcessingOperation::ComponentTransform { .. })
)
.then_some(ComponentAccumulationOrder::LaneAscending);
Self::Applied {
requested,
resolved: Box::new(resolved),
input_descriptor,
output_descriptor,
algorithm_version,
accumulation_order,
diagnostics,
}
}
pub(crate) fn attempted(
requested: impl Into<ProcessingRequest>,
failure: AttemptFailure,
diagnostics: Vec<ProcessingDiagnostic>,
) -> Self {
Self::Attempted {
requested: requested.into(),
failure,
diagnostics,
}
}
}