Skip to main content

qualia_core_db/q42/field_semantics/
rules.rs

1use super::*;
2/// Exact type/count rule; None count admits a bounded array/string length.
3#[derive(Clone, Copy, Debug)]
4pub struct FieldRule {
5    pub key: u16,
6    pub type_tag: u8,
7    pub count: Option<u32>,
8    pub required: bool,
9}
10const fn r(key: u16, type_tag: u8, count: Option<u32>, required: bool) -> FieldRule {
11    FieldRule {
12        key,
13        type_tag,
14        count,
15        required,
16    }
17}
18const CLOCK: &[FieldRule] = &[
19    r(1, 1, Some(1), true),
20    r(2, 3, Some(1), true),
21    r(3, 1, Some(1), true),
22    r(4, 2, Some(1), true),
23    r(5, 2, Some(1), true),
24];
25const FRAME: &[FieldRule] = &[
26    r(1, 1, Some(1), true),
27    r(2, 8, Some(1), false),
28    r(3, 5, Some(3), true),
29    r(4, 5, Some(4), true),
30    r(5, 5, Some(3), false),
31    r(6, 1, Some(3), false),
32    r(7, 1, Some(1), false),
33    r(8, 6, None, true),
34    r(9, 7, None, false),
35];
36const DESC: &[FieldRule] = &[
37    r(1, 8, Some(1), false),
38    r(2, 8, Some(1), false),
39    r(3, 8, Some(1), true),
40    r(4, 8, Some(1), false),
41    r(5, 8, Some(1), false),
42    r(6, 8, Some(1), false),
43    r(7, 6, None, true),
44    r(8, 6, None, true),
45    r(9, 1, Some(1), false),
46    r(10, 6, None, false),
47    r(11, 1, Some(1), false),
48    r(12, 6, None, true),
49    r(13, 2, Some(1), false),
50    r(14, 2, Some(1), false),
51    r(15, 2, Some(1), false),
52    r(16, 9, Some(1), false),
53    r(17, 9, None, false),
54    r(18, 8, None, false),
55];
56const PROV: &[FieldRule] = &[
57    r(1, 1, Some(1), true),
58    r(2, 7, None, false),
59    r(3, 6, None, false),
60    r(4, 6, None, false),
61    r(5, 6, None, false),
62    r(6, 7, Some(32), false),
63    r(7, 6, None, false),
64];
65const INSTANT: &[FieldRule] = &[
66    r(1, 8, Some(1), true),
67    r(2, 3, Some(1), true),
68    r(3, 2, Some(1), true),
69    r(4, 2, Some(1), true),
70];
71pub(super) fn shared_rules(schema: u16, revision: u16) -> Option<&'static [FieldRule]> {
72    if revision != 1 {
73        return None;
74    }
75    match schema {
76        1 => Some(CLOCK),
77        2 => Some(FRAME),
78        3 => Some(DESC),
79        4 => Some(PROV),
80        5 => Some(INSTANT),
81        _ => None,
82    }
83}
84/// Exact representation and required-critical checks, reusable by domain registries.
85/// Unknown optional keys remain preserved. Critical unknown keys/types reject.
86pub fn validate_fields(block: Block<'_>, rules: &[FieldRule]) -> Result<(), Error> {
87    for rule in rules {
88        if rule.required {
89            let f = required(block, rule.key)?;
90            if f.flags() & 1 == 0 {
91                return Err(Error::RequiredCritical);
92            }
93        }
94    }
95    for f in block.fields() {
96        if !(1..=11).contains(&f.type_tag()) && f.flags() & 1 != 0 {
97            return Err(Error::UnknownCriticalType);
98        }
99        if let Some(rule) = rules.iter().find(|r| r.key == f.key()) {
100            if f.type_tag() != rule.type_tag || rule.count.is_some_and(|n| n != f.element_count()) {
101                return Err(Error::FieldType);
102            }
103        } else if f.flags() & 1 != 0 {
104            return Err(Error::UnknownCriticalField);
105        }
106    }
107    Ok(())
108}