aces 0.0.7

Algebra of Cause-Effect Structures
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

use std::{fmt, error::Error};
use crate::{node, LinkID};

#[derive(Debug, Clone)]
pub enum AcesError {
    ContextMismatch,
    PortMismatch,
    SplitMismatch,
    NodeMissingForID,
    AtomMissingForID,
    PortMissingForID,
    LinkMissingForID(LinkID),
    SplitMissingForID,
    ForkMissingForID,
    JoinMissingForID,
    BottomAtomAccess,
    AtomicsNotOrdered,

    NodeMissingForPort(node::Face),
    NodeMissingForLink(node::Face),
    NodeMissingForFork(node::Face),
    NodeMissingForJoin(node::Face),
    FiringNodeMissing(node::Face),
    FiringNodeDuplicated(node::Face),
    IncoherentStructure(String),

    EmptyClauseRejectedByFormula(String),
    EmptyClauseRejectedBySolver(String),
    EmptyCausesOfInternalNode(String),
    EmptyEffectsOfInternalNode(String),

    UnlistedAtomicInMonomial,
    IncoherencyLeak,
    NoModelToInhibit,
}

impl fmt::Display for AcesError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use AcesError::*;

        match self {
            LinkMissingForID(link_id) => write!(f, "There is no link with ID {:?}", link_id),
            NodeMissingForPort(face) => write!(
                f,
                "Missing node for {} port",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            NodeMissingForLink(face) => write!(
                f,
                "Missing {} node for link",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            NodeMissingForFork(face) => write!(
                f,
                "Missing {} node for fork",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            NodeMissingForJoin(face) => write!(
                f,
                "Missing {} node for join",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            FiringNodeMissing(face) => write!(
                f,
                "Missing {} node in firing component",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            FiringNodeDuplicated(face) => write!(
                f,
                "Duplicated {} node in firing component",
                if *face == node::Face::Tx { "sending" } else { "receiving" }
            ),
            IncoherentStructure(name) => write!(f, "Structure '{}' is incoherent", name),
            EmptyClauseRejectedByFormula(name) => {
                write!(f, "Empty {} clause rejected by formula", name)
            }
            EmptyClauseRejectedBySolver(name) => {
                write!(f, "Empty {} clause rejected by solver", name)
            }
            EmptyCausesOfInternalNode(name) => {
                write!(f, "Empty cause polynomial of internal node '{}'", name)
            }
            EmptyEffectsOfInternalNode(name) => {
                write!(f, "Empty effect polynomial of internal node '{}'", name)
            }
            _ => write!(f, "{}", self.description()),
        }
    }
}

impl Error for AcesError {
    fn description(&self) -> &str {
        use AcesError::*;

        match self {
            ContextMismatch => "Context mismatch",
            PortMismatch => "Port (dock) mismatch",
            SplitMismatch => "Split (fork/join) mismatch",
            NodeMissingForID => "Node is missing for ID",
            AtomMissingForID => "Atom is missing for ID",
            PortMissingForID => "Port is missing for ID",
            LinkMissingForID(_) => "Link is missing for ID",
            SplitMissingForID => "Split is missing for ID",
            ForkMissingForID => "Fork is missing for ID",
            JoinMissingForID => "Join is missing for ID",
            BottomAtomAccess => "Attempt to access the bottom atom",
            AtomicsNotOrdered => "Atomics have to be given in strictly increasing order",

            NodeMissingForPort(_) => "Missing node for port",
            NodeMissingForLink(_) => "Missing node for link",
            NodeMissingForFork(_) => "Missing node for fork",
            NodeMissingForJoin(_) => "Missing node for join",
            FiringNodeMissing(_) => "Missing node in firing component",
            FiringNodeDuplicated(_) => "Duplicated node in firing component",
            IncoherentStructure(_) => "Incoherent c-e structure",

            EmptyClauseRejectedByFormula(_) => "Empty clause rejected by formula",
            EmptyClauseRejectedBySolver(_) => "Empty clause rejected by solver",
            EmptyCausesOfInternalNode(_) => "Empty cause polynomial of internal node",
            EmptyEffectsOfInternalNode(_) => "Empty effect polynomial of internal node",

            UnlistedAtomicInMonomial => "Monomial contains an unlisted atomic",
            IncoherencyLeak => "Unexpected incoherence of a c-e structure",
            NoModelToInhibit => "Attempt to inhibit a nonexistent model",
        }
    }
}