icydb-schema 0.300.0

Bounded public schema proposal contract for IcyDB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Bounded source-side durable-rule operations.
//!
//! These values are proposal facts. Accepted schema resolves their nominal
//! target and owns every runtime evaluator.

use serde::{Deserialize, Serialize};

use crate::{ScalarKind, ScalarLiteral, SchemaContractError};

/// One closed durable operation applied to every selected nominal value.
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum SourceRuleOperation {
    /// Inclusive Unicode-scalar, octet, or collection-cardinality range.
    LengthRangeInclusive {
        /// Inclusive minimum length.
        min: u64,
        /// Inclusive maximum length.
        max: u64,
    },
    /// Exact nonzero integer or fixed-scale decimal divisor.
    MultipleOf {
        /// Exact divisor admitted against the target kind.
        divisor: ScalarLiteral,
    },
    /// Inclusive upper bound for one exact numeric kind.
    NumericMaximumInclusive {
        /// Exact upper-bound literal.
        value: ScalarLiteral,
    },
    /// Inclusive lower bound for one exact numeric kind.
    NumericMinimumInclusive {
        /// Exact lower-bound literal.
        value: ScalarLiteral,
    },
    /// Inclusive lower and upper bounds for one exact numeric kind.
    NumericRangeInclusive {
        /// Exact lower-bound literal.
        min: ScalarLiteral,
        /// Exact upper-bound literal.
        max: ScalarLiteral,
    },
}

impl SourceRuleOperation {
    /// Validate the bounded operation independently of its eventual target.
    pub(crate) fn validate(&self) -> Result<(), SchemaContractError> {
        match self {
            Self::LengthRangeInclusive { min, max } if min <= max => Ok(()),
            Self::MultipleOf { divisor }
                if exact_multiple_literal(divisor) && !scalar_literal_is_zero(divisor) =>
            {
                divisor.validate()
            }
            Self::NumericMaximumInclusive { value } | Self::NumericMinimumInclusive { value }
                if numeric_literal(value) =>
            {
                value.validate()
            }
            Self::NumericRangeInclusive { min, max }
                if numeric_literal(min)
                    && min.kind() == max.kind()
                    && scalar_literal_le(min, max) =>
            {
                min.validate()?;
                max.validate()
            }
            Self::LengthRangeInclusive { .. }
            | Self::MultipleOf { .. }
            | Self::NumericMaximumInclusive { .. }
            | Self::NumericMinimumInclusive { .. }
            | Self::NumericRangeInclusive { .. } => Err(SchemaContractError::InvalidRuleOperation),
        }
    }
}

pub(crate) const fn exact_multiple_literal(literal: &ScalarLiteral) -> bool {
    matches!(
        literal.kind(),
        ScalarKind::Decimal | ScalarKind::Int128 | ScalarKind::Nat128
    )
}

const fn numeric_literal(literal: &ScalarLiteral) -> bool {
    matches!(
        literal.kind(),
        ScalarKind::Decimal
            | ScalarKind::Float32
            | ScalarKind::Float64
            | ScalarKind::Int128
            | ScalarKind::Nat128
            | ScalarKind::U256
    )
}

fn scalar_literal_le(left: &ScalarLiteral, right: &ScalarLiteral) -> bool {
    match (left, right) {
        (ScalarLiteral::Decimal(left), ScalarLiteral::Decimal(right)) => left <= right,
        (ScalarLiteral::Float32(left), ScalarLiteral::Float32(right)) => left <= right,
        (ScalarLiteral::Float64(left), ScalarLiteral::Float64(right)) => left <= right,
        (ScalarLiteral::Int(left), ScalarLiteral::Int(right)) => left <= right,
        (ScalarLiteral::Nat(left), ScalarLiteral::Nat(right)) => left <= right,
        (ScalarLiteral::U256(left), ScalarLiteral::U256(right)) => left <= right,
        _ => false,
    }
}

fn scalar_literal_is_zero(literal: &ScalarLiteral) -> bool {
    match literal {
        ScalarLiteral::Decimal(value) => value.is_zero(),
        ScalarLiteral::Int(value) => *value == 0,
        ScalarLiteral::Nat(value) => *value == 0,
        ScalarLiteral::U256(value) => *value == crate::U256::ZERO,
        ScalarLiteral::Account(_)
        | ScalarLiteral::Blob(_)
        | ScalarLiteral::Bool(_)
        | ScalarLiteral::Date(_)
        | ScalarLiteral::Duration(_)
        | ScalarLiteral::EnumUnit { .. }
        | ScalarLiteral::Float32(_)
        | ScalarLiteral::Float64(_)
        | ScalarLiteral::Principal(_)
        | ScalarLiteral::Subaccount(_)
        | ScalarLiteral::Text(_)
        | ScalarLiteral::Timestamp(_)
        | ScalarLiteral::Ulid(_)
        | ScalarLiteral::Unit(_) => false,
    }
}

#[cfg(test)]
mod tests;