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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

/*
This Rust module contains the SDML model of the SDML library module `sdml`.
*/

use crate::model::annotations::AnnotationBuilder;
use crate::model::modules::{ImportStatement, Module};
use crate::model::HasBody;
use url::Url;

// ------------------------------------------------------------------------------------------------
// Public Macros
// ------------------------------------------------------------------------------------------------

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

pub const MODULE_NAME: &str = "sdml";
pub const MODULE_URL: &str = "http://sdml.io/sdml-owl.ttl#";

pub const CLASS_ANNOTATION_NAME: &str = "Annotation";
pub const CLASS_ANNOTATION_PROPERTY_NAME: &str = "AnnotationProperty";
pub const CLASS_CARDINALITY_NAME: &str = "Cardinality";
pub const CLASS_CONSTRAINT_NAME: &str = "Constraint";
pub const CLASS_DEFINITION_NAME: &str = "Definition";
pub const CLASS_ENTITY_NAME: &str = "Entity";
pub const CLASS_ENUMERATION_NAME: &str = "Enumeration";
pub const CLASS_EVENT_NAME: &str = "Event";
pub const CLASS_FORMAL_CONSTRAINT_NAME: &str = "FormalConstraint";
pub const CLASS_IDENTIFIER_REFERENCE_NAME: &str = "IdentifierReference";
pub const CLASS_IMPORT_NAME: &str = "Import";
pub const CLASS_IMPORT_STATEMENT_NAME: &str = "ImportStatement";
pub const CLASS_INFORMAL_CONSTRAINT_NAME: &str = "InformalConstraint";
pub const CLASS_MEMBER_NAME: &str = "Member";
pub const CLASS_MEMBER_IMPORT_NAME: &str = "MemberImport";
pub const CLASS_MODULE_NAME: &str = "Module";
pub const CLASS_MODULE_IMPORT_NAME: &str = "ModuleImport";
pub const CLASS_PROPERTY_NAME: &str = "Property";
pub const CLASS_ROLE_NAME: &str = "Role";
pub const CLASS_QUALIFIED_IDENTIFIER_NAME: &str = "QualifiedIdentifier";
pub const CLASS_STRUCTURE_NAME: &str = "Structure";
pub const CLASS_TYPE_VARIANT_NAME: &str = "TypeVariant";
pub const CLASS_UNION_NAME: &str = "Union";
pub const CLASS_VALUE_VARIANT_NAME: &str = "ValueVariant";

pub const DT_IDENTIFIER_NAME: &str = "Identifier";

pub const DT_BINARY_NAME: &str = "binary";
pub const DT_BOOLEAN_NAME: &str = "boolean";
pub const DT_DECIMAL_NAME: &str = "decimal";
pub const DT_DOUBLE_NAME: &str = "double";
pub const DT_INTEGER_NAME: &str = "string";
pub const DT_IRI_NAME: &str = "iri";
pub const DT_LANGUAGE_NAME: &str = "language";
pub const DT_STRING_NAME: &str = "string";
pub const DT_UNSIGNED_NAME: &str = "unsigned";

pub const PROP_HAS_NAME_NAME: &str = "hasName";
pub const PROP_HAS_ANNOTATION_NAME: &str = "hasAnnotation";
pub const PROP_HAS_CARDINALITY_NAME: &str = "hasCardinality";
pub const PROP_HAS_DEFINITION_NAME: &str = "hasDefinition";
pub const PROP_HAS_IMPORT_STATEMENT_NAME: &str = "hasImportStatement";
pub const PROP_HAS_MEMBER_NAME: &str = "hasMember";
pub const PROP_HAS_TYPE_VARIANT_NAME: &str = "hasTypeVariant";
pub const PROP_HAS_VALUE_VARIANT_NAME: &str = "hasValueVariant";

pub const PROP_MAX_OCCURS_NAME: &str = "maxOccurs";
pub const PROP_MIN_OCCURS_NAME: &str = "minOccurs";
pub const PROP_ORDERING_NAME: &str = "ordering";
pub const PROP_UNIQUENESS_NAME: &str = "uniqueness";

// ------------------------------------------------------------------------------------------------
// Public Functions
// ------------------------------------------------------------------------------------------------

pub fn module() -> Module {
    #[allow(non_snake_case)]
    let MODULE_IRI: url::Url = url::Url::parse(MODULE_URL).unwrap();
    let mut module = Module::empty(id!(MODULE_NAME)).with_base_uri(Url::parse(MODULE_URL).unwrap());

    module
        .body_mut()
        .add_to_imports(ImportStatement::new_module(id!(super::rdf::MODULE_NAME)));
    module
        .body_mut()
        .add_to_imports(ImportStatement::new_module(id!(super::rdfs::MODULE_NAME)));
    module
        .body_mut()
        .add_to_imports(ImportStatement::new_module(id!(super::xsd::MODULE_NAME)));

    module.body_mut().extend_definitions(vec![
        // Classes
        rdf!(class CLASS_ANNOTATION_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_ANNOTATION_PROPERTY_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_CARDINALITY_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_CONSTRAINT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_DEFINITION_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_ENTITY_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_ENUMERATION_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_EVENT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_FORMAL_CONSTRAINT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_IDENTIFIER_REFERENCE_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_IMPORT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_IMPORT_STATEMENT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_INFORMAL_CONSTRAINT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_MEMBER_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_MEMBER_IMPORT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_MODULE_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_MODULE_IMPORT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_PROPERTY_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_ROLE_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_QUALIFIED_IDENTIFIER_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_STRUCTURE_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_TYPE_VARIANT_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_UNION_NAME, MODULE_IRI).into(),
        rdf!(class CLASS_VALUE_VARIANT_NAME, MODULE_IRI).into(),
        // Data types
        rdf!(datatype DT_IDENTIFIER_NAME, MODULE_IRI).into(),
        rdf!(datatype DT_BINARY_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_HEX_BINARY_NAME
            ))
            .into(),
        rdf!(datatype DT_BOOLEAN_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_BOOLEAN_NAME
            ))
            .into(),
        rdf!(datatype DT_DECIMAL_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_DECIMAL_NAME
            ))
            .into(),
        rdf!(datatype DT_DOUBLE_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(super::xsd::MODULE_NAME, super::xsd::DT_DOUBLE_NAME))
            .into(),
        rdf!(datatype DT_INTEGER_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_INTEGER_NAME
            ))
            .into(),
        rdf!(datatype DT_UNSIGNED_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_NONNEGATIVE_INTEGER_NAME
            ))
            .into(),
        rdf!(datatype DT_IRI_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_ANY_URI_NAME
            ))
            .into(),
        rdf!(datatype DT_LANGUAGE_NAME, MODULE_IRI)
            .with_equivalent_class(qualid!(
                super::xsd::MODULE_NAME,
                super::xsd::DT_LANGUAGE_NAME
            ))
            .into(),
        // Properties
        rdf!(class PROP_HAS_ANNOTATION_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_CARDINALITY_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_DEFINITION_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_IMPORT_STATEMENT_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_MEMBER_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_NAME_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_TYPE_VARIANT_NAME, MODULE_IRI).into(),
        rdf!(class PROP_HAS_VALUE_VARIANT_NAME, MODULE_IRI).into(),
        rdf!(class PROP_MAX_OCCURS_NAME, MODULE_IRI).into(),
        rdf!(class PROP_MIN_OCCURS_NAME, MODULE_IRI).into(),
        rdf!(class PROP_ORDERING_NAME, MODULE_IRI).into(),
        rdf!(class PROP_UNIQUENESS_NAME, MODULE_IRI).into(),
    ]);

    module
}

// ------------------------------------------------------------------------------------------------
// Private Macros
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Private Types
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Private Functions
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Modules
// ------------------------------------------------------------------------------------------------