graphforge-knowledge 0.6.0-rc.1

Immutable GraphForge knowledge and epistemic record domains
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

//! Frozen closed spellings shared by Arrow and canonical content.
use super::{ClaimRelationKind, ResearchCategory, ResearchDecisionKind, ResearchSubjectKind};
use crate::{KnowledgeError, invalid};
impl ResearchCategory {
    /// Exact persisted contract spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::MachineExtraction => "machine_extraction",
            Self::AnalystAssertion => "analyst_assertion",
            Self::Interpretation => "interpretation",
            Self::Hypothesis => "hypothesis",
            Self::Theory => "theory",
            Self::Annotation => "annotation",
        }
    }
    pub(super) fn parse(value: &str) -> Result<Self, KnowledgeError> {
        match value {
            "machine_extraction" => Ok(Self::MachineExtraction),
            "analyst_assertion" => Ok(Self::AnalystAssertion),
            "interpretation" => Ok(Self::Interpretation),
            "hypothesis" => Ok(Self::Hypothesis),
            "theory" => Ok(Self::Theory),
            "annotation" => Ok(Self::Annotation),
            _ => Err(invalid(
                "ResearchCategory",
                "unsupported closed registry value",
            )),
        }
    }
}
impl ClaimRelationKind {
    /// Exact persisted contract spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::AlternativeTo => "alternative_to",
            Self::Contradicts => "contradicts",
            Self::Disputes => "disputes",
            Self::Refines => "refines",
            Self::Supersedes => "supersedes",
            Self::Supports => "supports",
        }
    }
    pub(super) fn parse(value: &str) -> Result<Self, KnowledgeError> {
        match value {
            "alternative_to" => Ok(Self::AlternativeTo),
            "contradicts" => Ok(Self::Contradicts),
            "disputes" => Ok(Self::Disputes),
            "refines" => Ok(Self::Refines),
            "supersedes" => Ok(Self::Supersedes),
            "supports" => Ok(Self::Supports),
            _ => Err(invalid(
                "ClaimRelationKind",
                "unsupported closed registry value",
            )),
        }
    }
}
impl ResearchSubjectKind {
    /// Exact persisted contract spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Node => "node",
            Self::Edge => "edge",
            Self::Assertion => "assertion",
        }
    }
    pub(super) fn parse(value: &str) -> Result<Self, KnowledgeError> {
        match value {
            "node" => Ok(Self::Node),
            "edge" => Ok(Self::Edge),
            "assertion" => Ok(Self::Assertion),
            _ => Err(invalid(
                "ResearchSubjectKind",
                "unsupported closed registry value",
            )),
        }
    }
}
impl ResearchDecisionKind {
    /// Exact persisted contract spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Integrate => "integrate",
            Self::Promote => "promote",
            Self::Revoke => "revoke",
        }
    }
    pub(super) fn parse(value: &str) -> Result<Self, KnowledgeError> {
        match value {
            "integrate" => Ok(Self::Integrate),
            "promote" => Ok(Self::Promote),
            "revoke" => Ok(Self::Revoke),
            _ => Err(invalid(
                "ResearchDecisionKind",
                "unsupported closed registry value",
            )),
        }
    }
}