Skip to main content

qualia_core_db/bundle/stream/formats/
qac.rs

1use super::{AuthenticatedRange, FormatError};
2use crate::audio::qac::{signal, QacStorageError, QacStorageOptions, QacStorageView};
3use crate::q42::{field_envelope, field_semantics};
4/// Authenticated complete current .qac entry. Partial ranges and legacy UA4Q refuse.
5pub struct QacCompleteView<'a> {
6    range: AuthenticatedRange<'a>,
7    storage: QacStorageView<'a>,
8}
9#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10pub enum QacAdmitError {
11    Format(FormatError),
12    Family,
13    Version,
14    Extent,
15    Crc,
16    IndexDigest,
17    PayloadDigest,
18    Limit,
19    Unsupported,
20    Index,
21    Shape,
22    Scalar,
23    Unit,
24    Clock,
25    Overflow,
26    Nonfinite,
27    Shared(field_semantics::Error),
28    Envelope(field_envelope::Error),
29}
30impl From<FormatError> for QacAdmitError {
31    fn from(e: FormatError) -> Self {
32        Self::Format(e)
33    }
34}
35impl From<field_envelope::Error> for QacAdmitError {
36    fn from(e: field_envelope::Error) -> Self {
37        match e {
38            field_envelope::Error::Family => Self::Family,
39            field_envelope::Error::Version => Self::Version,
40            field_envelope::Error::Extent => Self::Extent,
41            field_envelope::Error::Crc => Self::Crc,
42            field_envelope::Error::IndexDigest => Self::IndexDigest,
43            field_envelope::Error::PayloadDigest => Self::PayloadDigest,
44            field_envelope::Error::Limit => Self::Limit,
45            other => Self::Envelope(other),
46        }
47    }
48}
49impl From<QacStorageError> for QacAdmitError {
50    fn from(e: QacStorageError) -> Self {
51        match e {
52            QacStorageError::Envelope(err) => err.into(),
53        }
54    }
55}
56fn map_signal_error(e: signal::Error) -> QacAdmitError {
57    match e {
58        signal::Error::Envelope(err) => err.into(),
59        signal::Error::Shared(err) => match err {
60            field_semantics::Error::UnknownCriticalSchema
61            | field_semantics::Error::UnknownCriticalField
62            | field_semantics::Error::UnknownCriticalType
63            | field_semantics::Error::UnsupportedDomain
64            | field_semantics::Error::RequiredCritical
65            | field_semantics::Error::MissingField => QacAdmitError::Unsupported,
66            field_semantics::Error::Limit => QacAdmitError::Limit,
67            field_semantics::Error::Overflow => QacAdmitError::Overflow,
68            other => QacAdmitError::Shared(other),
69        },
70        signal::Error::Unsupported | signal::Error::Profile => QacAdmitError::Unsupported,
71        signal::Error::Shape => QacAdmitError::Shape,
72        signal::Error::Scalar => QacAdmitError::Scalar,
73        signal::Error::Unit => QacAdmitError::Unit,
74        signal::Error::Clock => QacAdmitError::Clock,
75        signal::Error::Overflow => QacAdmitError::Overflow,
76        signal::Error::Nonfinite => QacAdmitError::Nonfinite,
77        signal::Error::Index => QacAdmitError::Index,
78        signal::Error::Limit => QacAdmitError::Limit,
79    }
80}
81impl<'a> QacCompleteView<'a> {
82    /// Whole selected entry only. `QacStorageView::open` dispatches on magic/version bytes.
83    pub fn admit(
84        range: AuthenticatedRange<'a>,
85        options: QacStorageOptions,
86    ) -> Result<Self, QacAdmitError> {
87        if range.offset() != 0 || range.bytes().len() as u64 != range.selected().logical_length() {
88            return Err(QacAdmitError::Extent);
89        }
90        Ok(Self {
91            range,
92            storage: QacStorageView::open(range.bytes(), options)?,
93        })
94    }
95    pub const fn range(&self) -> AuthenticatedRange<'a> {
96        self.range
97    }
98    pub fn storage(&self) -> &QacStorageView<'a> {
99        &self.storage
100    }
101    /// Scientific interpretation. Storage admit already succeeded.
102    /// Unsupported / Profile / unknown critical → `QacAdmitError::Unsupported`
103    /// (caller may still keep the complete entry as OpaqueArchival).
104    pub fn admit_signal<'s>(
105        &'s self,
106        selected: u32,
107        scratch: &mut field_semantics::Scratch<'_>,
108        shared: field_semantics::Limits,
109        limits: signal::Limits,
110    ) -> Result<signal::SignalView<'s>, QacAdmitError> {
111        signal::admit(
112            self.storage().structure(),
113            selected,
114            scratch,
115            shared,
116            limits,
117        )
118        .map_err(map_signal_error)
119    }
120}