lsp-max 26.7.3

Law-state LSP runtime: max LSP 3.18 coverage, process-mining conformance, receipt-chain admission
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

use crate::andon::andon::AndonEvent;
use crate::andon::core::RepairAction;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DtContext {
    pub seq: Option<u64>,
    pub workspace_id: String,
    pub timestamp: String,
    pub admission_allowed: Option<bool>,
    pub active_andon_codes: Vec<String>,
    pub active_invariant_ids: Vec<String>,
    pub governing_axes: Vec<String>,
    pub events: Vec<AndonEvent>,
    pub repairs: Vec<RepairAction>,
    pub required_commands: Vec<String>,
    pub virtual_doc_uris: Vec<String>,
    pub gate_file: Option<String>,
}

#[derive(Debug, PartialEq, Eq)]
pub enum DtStatus {
    Valid,
    Refused,
    Stop,
}

impl DtContext {
    pub fn empty() -> Self {
        Self {
            seq: None,
            workspace_id: String::new(),
            timestamp: String::new(),
            admission_allowed: None,
            active_andon_codes: Vec::new(),
            active_invariant_ids: Vec::new(),
            governing_axes: Vec::new(),
            events: Vec::new(),
            repairs: Vec::new(),
            required_commands: Vec::new(),
            virtual_doc_uris: Vec::new(),
            gate_file: None,
        }
    }

    pub fn is_empty(&self) -> bool {
        self.active_andon_codes.is_empty()
            && self.active_invariant_ids.is_empty()
            && self.events.is_empty()
    }

    pub fn validate(&self, has_active_gate: bool) -> DtStatus {
        if self.is_empty() && has_active_gate {
            return DtStatus::Refused;
        }

        if self.seq.is_none() {
            return DtStatus::Stop;
        }

        if self.admission_allowed.is_none() {
            return DtStatus::Stop;
        }

        let has_blocking_events = self.events.iter().any(|e| e.blocking);
        if has_blocking_events && self.repairs.is_empty() {
            return DtStatus::Stop;
        }

        DtStatus::Valid
    }
}