use cadmpeg_ir::report::{
loss::{LossKind, LossNamespace, LossNote, LossTaxonomy},
Severity,
};
const NAMESPACE: LossNamespace<'static> = match LossNamespace::new("sat") {
Ok(namespace) => namespace,
Err(_) => panic!("reserved codec namespace"),
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) enum SatLossCode {
GeometryFramedWithoutCarriers,
GeometryProceduralSurfaceUntyped,
GeometryUseCurveIntervalInvalid,
VertexToleranceUnresolved,
EdgeToleranceUnresolved,
TopologyShellUnprojected,
TopologyFaceOwnerUnprojected,
TopologyWireOwnerUnprojected,
SourceRecordNameUnresolved,
SourceRecordExtensionsUnprojected,
HeaderToleranceUnresolved,
HeaderMetadataNoncanonical,
HeaderLengthUnitUnresolved,
FramingTerminatorMissing,
FramingRecordsUnread,
SourceDialectUnverified,
SourceConcatenatedStreamsRecovered,
SourceStreamLayoutUnprojected,
}
impl SatLossCode {
#[cfg(test)]
const ALL: &'static [SatLossCode] = &[
Self::GeometryFramedWithoutCarriers,
Self::GeometryProceduralSurfaceUntyped,
Self::GeometryUseCurveIntervalInvalid,
Self::VertexToleranceUnresolved,
Self::EdgeToleranceUnresolved,
Self::TopologyShellUnprojected,
Self::TopologyFaceOwnerUnprojected,
Self::TopologyWireOwnerUnprojected,
Self::SourceRecordNameUnresolved,
Self::SourceRecordExtensionsUnprojected,
Self::HeaderToleranceUnresolved,
Self::HeaderMetadataNoncanonical,
Self::HeaderLengthUnitUnresolved,
Self::FramingTerminatorMissing,
Self::FramingRecordsUnread,
Self::SourceDialectUnverified,
Self::SourceConcatenatedStreamsRecovered,
Self::SourceStreamLayoutUnprojected,
];
#[must_use]
const fn code(self) -> &'static str {
match self {
Self::GeometryFramedWithoutCarriers => "geometry.framed-without-carriers",
Self::GeometryProceduralSurfaceUntyped => "geometry.procedural-surface-untyped",
Self::GeometryUseCurveIntervalInvalid => "geometry.use-curve-interval-invalid",
Self::VertexToleranceUnresolved => "vertex.tolerance-unresolved",
Self::EdgeToleranceUnresolved => "edge.tolerance-unresolved",
Self::TopologyShellUnprojected => "topology.shell-unprojected",
Self::TopologyFaceOwnerUnprojected => "topology.face-owner-unprojected",
Self::TopologyWireOwnerUnprojected => "topology.wire-owner-unprojected",
Self::SourceRecordNameUnresolved => "source.record-name-unresolved",
Self::SourceRecordExtensionsUnprojected => "source.record-extensions-unprojected",
Self::HeaderToleranceUnresolved => "header.tolerance-unresolved",
Self::HeaderMetadataNoncanonical => "header.metadata-noncanonical",
Self::HeaderLengthUnitUnresolved => "header.length-unit-unresolved",
Self::FramingTerminatorMissing => "framing.terminator-missing",
Self::FramingRecordsUnread => "framing.records-unread",
Self::SourceDialectUnverified => "source.kernel-dialect-unverified",
Self::SourceConcatenatedStreamsRecovered => "source.concatenated-streams-recovered",
Self::SourceStreamLayoutUnprojected => "source.stream-layout-unprojected",
}
}
#[must_use]
const fn severity(self) -> Severity {
match self {
Self::GeometryFramedWithoutCarriers => Severity::Blocking,
Self::GeometryProceduralSurfaceUntyped
| Self::GeometryUseCurveIntervalInvalid
| Self::EdgeToleranceUnresolved
| Self::VertexToleranceUnresolved
| Self::TopologyShellUnprojected
| Self::TopologyFaceOwnerUnprojected
| Self::TopologyWireOwnerUnprojected
| Self::SourceRecordNameUnresolved
| Self::SourceRecordExtensionsUnprojected
| Self::HeaderToleranceUnresolved
| Self::HeaderMetadataNoncanonical
| Self::HeaderLengthUnitUnresolved
| Self::FramingTerminatorMissing
| Self::FramingRecordsUnread
| Self::SourceDialectUnverified
| Self::SourceConcatenatedStreamsRecovered
| Self::SourceStreamLayoutUnprojected => Severity::Warning,
}
}
const fn shared_taxonomy(self) -> LossTaxonomy {
match self {
Self::GeometryFramedWithoutCarriers
| Self::GeometryProceduralSurfaceUntyped
| Self::HeaderToleranceUnresolved
| Self::GeometryUseCurveIntervalInvalid
| Self::EdgeToleranceUnresolved
| Self::VertexToleranceUnresolved
| Self::TopologyShellUnprojected
| Self::TopologyFaceOwnerUnprojected
| Self::TopologyWireOwnerUnprojected
| Self::HeaderLengthUnitUnresolved
| Self::FramingRecordsUnread
| Self::SourceStreamLayoutUnprojected => LossTaxonomy::GeometryNotTransferred,
Self::SourceDialectUnverified => LossTaxonomy::SourceDialectUnverified,
Self::SourceRecordExtensionsUnprojected => LossTaxonomy::GeometryNotTransferred,
Self::SourceConcatenatedStreamsRecovered
| Self::HeaderMetadataNoncanonical
| Self::FramingTerminatorMissing
| Self::SourceRecordNameUnresolved => LossTaxonomy::NoncanonicalSourceSyntax,
}
}
#[must_use]
pub(crate) fn kind(self) -> LossKind {
LossKind::namespaced(NAMESPACE, self.code(), self.shared_taxonomy())
}
#[must_use]
pub(crate) fn note(self, message: impl Into<String>) -> LossNote {
LossNote::new(self.kind(), message).with_severity(self.severity())
}
}
pub(crate) fn text_stream_losses<'a>(
diagnostics: impl IntoIterator<Item = &'a cadmpeg_asm::sat::StreamDiagnostic>,
unread_layout_offset: Option<usize>,
losses: &mut Vec<LossNote>,
) {
use cadmpeg_asm::sat::StreamDiagnosticKind;
for diagnostic in diagnostics {
let code = match diagnostic.kind {
StreamDiagnosticKind::Metadata => SatLossCode::HeaderMetadataNoncanonical,
StreamDiagnosticKind::Tolerance => SatLossCode::HeaderToleranceUnresolved,
StreamDiagnosticKind::Units => SatLossCode::HeaderLengthUnitUnresolved,
StreamDiagnosticKind::Terminator => SatLossCode::FramingTerminatorMissing,
StreamDiagnosticKind::Unread
if unread_layout_offset == Some(diagnostic.error.offset) =>
{
SatLossCode::SourceStreamLayoutUnprojected
}
StreamDiagnosticKind::Unread => SatLossCode::FramingRecordsUnread,
};
let message = format!(
"byte {}: {}; independent records retained",
diagnostic.error.offset, diagnostic.error.reason
);
losses.push(
code.note(message)
.with_provenance(cadmpeg_ir::SourceProvenance::root(
"sat",
cadmpeg_core::decode::u64_from_index(diagnostic.error.offset),
)),
);
}
}
pub(crate) fn binary_header_losses(
header: &cadmpeg_asm::kernel_header::KernelHeader,
losses: &mut Vec<LossNote>,
) {
for field in header.unreadable_product_fields() {
losses.push(SatLossCode::HeaderMetadataNoncanonical.note(format!(
"binary header {field} is unreadable; independent records retained"
)));
}
}
#[cfg(test)]
mod tests {
use super::SatLossCode;
use std::collections::BTreeSet;
#[test]
fn code_strings_are_pinned() {
let codes: Vec<&str> = SatLossCode::ALL.iter().map(|c| c.code()).collect();
assert_eq!(
codes,
[
"geometry.framed-without-carriers",
"geometry.procedural-surface-untyped",
"geometry.use-curve-interval-invalid",
"vertex.tolerance-unresolved",
"edge.tolerance-unresolved",
"topology.shell-unprojected",
"topology.face-owner-unprojected",
"topology.wire-owner-unprojected",
"source.record-name-unresolved",
"source.record-extensions-unprojected",
"header.tolerance-unresolved",
"header.metadata-noncanonical",
"header.length-unit-unresolved",
"framing.terminator-missing",
"framing.records-unread",
"source.kernel-dialect-unverified",
"source.concatenated-streams-recovered",
"source.stream-layout-unprojected",
]
);
}
#[test]
fn codes_are_unique_and_well_formed() {
let mut seen = BTreeSet::new();
for code in SatLossCode::ALL {
let text = code.code();
assert!(seen.insert(text), "duplicate code {text}");
let (family, detail) = text.split_once('.').expect("family.detail shape");
assert!(!family.is_empty() && !detail.is_empty());
assert!(
text.bytes()
.all(|b| b.is_ascii_lowercase() || b == b'.' || b == b'-'),
"code {text} is not lowercase kebab"
);
}
}
#[test]
fn note_takes_severity_from_the_code() {
for code in SatLossCode::ALL {
let note = code.note("x");
assert_eq!(note.severity, code.severity());
assert_eq!(note.message, "x");
assert!(note.provenance.is_none());
}
}
}