rdftk_core 0.5.6

This crate provides the core RDF data model; concrete implementations for Statements and Literals, along with a Resource type that provides a builder-like experience for models.
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

/*!
This module provides the trait [`Featured`] and the set of feature identifiers (IRIs).

Most of the data model types implement `Featured` which may be used to determine specific
capabilities provided by that type.

# Example

```rust
use rdftk_core::model::features::{Featured, FEATURE_GRAPH_DUPLICATES};
use rdftk_core::model::graph::Graph;

let graph = Graph::default();
println!("Allows Duplicates: {}", graph.supports_feature(&FEATURE_GRAPH_DUPLICATES));

let graph = Graph::unique();
println!("Allows Duplicates: {}", graph.supports_feature(&FEATURE_GRAPH_DUPLICATES));
```

*/
use lazy_static::lazy_static;
use rdftk_iri::Iri;
use std::str::FromStr;

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

///
/// Not all the features expressed in the Graph APIs are required to be implemented by a
/// particular type. This trait allows a client to determine which features are supported.
///
pub trait Featured {
    ///
    /// Return true if this instance, or factory, supports the feature identified by the Iri.
    ///
    fn supports_feature(&self, feature: &Iri) -> bool;
}

lazy_static! {

    // --------------------------------------------------------------------------------------------
    // DataSet features
    // --------------------------------------------------------------------------------------------

    ///
    /// If true, a data set's default graph is a combination of all named graphs. This implies
    /// that `set_default_graph` and `unset_default_graph` have no effect.
    ///
    pub static ref FEATURE_COMBINED_DEFAULT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/model.data_set/combined_default").unwrap()
    ;

    // --------------------------------------------------------------------------------------------
    // Graph/Statement features
    // --------------------------------------------------------------------------------------------

    ///
    /// Denotes that statements may include collections within subject nodes.
    ///
    pub static ref FEATURE_STMT_SUBJECT_COLLECTIONS: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/statements/subject_collections").unwrap();

    ///
    /// Denotes that statements may include collections within object nodes.
    ///
    pub static ref FEATURE_STMT_OBJECT_COLLECTIONS: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/statements/object_collections").unwrap();

    ///
    /// Denotes that this graph may be named.
    ///
    pub static ref FEATURE_GRAPH_ALLOWS_NAMED: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/graph/named").unwrap();

    ///
    /// Denotes that this graph accepts duplicate statements.
    ///
    pub static ref FEATURE_GRAPH_DUPLICATES: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/graph/duplicates").unwrap();

    ///
    /// This graph, or corresponding statement, supports
    /// [RDF-star](https://w3c.github.io/rdf-star/cg-spec/editors_draft.html).
    ///
    pub static ref FEATURE_RDF_STAR: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/graph/rdf_star").unwrap();

    ///
    /// This graph, or corresponding statement, supports
    /// [N3 Formula](https://www.w3.org/TeamSubmission/n3/#Quoting)
    ///
    pub static ref FEATURE_N3_FORMULAE: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/graph/n3_formulae").unwrap();

    // --------------------------------------------------------------------------------------------
    // Index features
    // --------------------------------------------------------------------------------------------

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_PREDICATE: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/predicate").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_OBJECT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/object").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_PREDICATE: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_predicate").unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_PREDICATE_OBJECT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_predicate_object").unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_OBJECT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_object").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_PREDICATE_OBJECT: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/predicate_object").unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/graph").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_graph").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_PREDICATE_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/predicate_graph").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_OBJECT_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/object_graph").unwrap();

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_PREDICATE_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_predicate_graph").unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_PREDICATE_OBJECT_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_predicate_object_graph")
            .unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_SUBJECT_OBJECT_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/subject_object_graph").unwrap()
    ;

    /// Used to determine whether a specific index combination is supported.
    pub static ref FEATURE_IDX_PREDICATE_OBJECT_GRAPH: Iri =
        Iri::from_str("http://rust-rdftk.dev/feature/index/predicate_object_graph").unwrap()
    ;
}