summaryrefslogtreecommitdiff
path: root/src/core/parser
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/parser')
-rw-r--r--src/core/parser/ParserScope.cpp2
-rw-r--r--src/core/parser/stack/DocumentHandler.cpp4
-rw-r--r--src/core/parser/stack/DocumentHandler.hpp2
-rw-r--r--src/core/parser/stack/GenericParserStates.cpp26
-rw-r--r--src/core/parser/stack/ImportIncludeHandler.cpp6
-rw-r--r--src/core/parser/stack/OntologyHandler.cpp (renamed from src/core/parser/stack/DomainHandler.cpp)170
-rw-r--r--src/core/parser/stack/OntologyHandler.hpp (renamed from src/core/parser/stack/DomainHandler.hpp)84
-rw-r--r--src/core/parser/stack/TypesystemHandler.cpp16
8 files changed, 155 insertions, 155 deletions
diff --git a/src/core/parser/ParserScope.cpp b/src/core/parser/ParserScope.cpp
index dabb03c..c46dc51 100644
--- a/src/core/parser/ParserScope.cpp
+++ b/src/core/parser/ParserScope.cpp
@@ -19,7 +19,7 @@
#include <core/common/Exceptions.hpp>
#include <core/common/Utils.hpp>
#include <core/common/VariantWriter.hpp>
-#include <core/model/Domain.hpp>
+#include <core/model/Ontology.hpp>
#include <core/model/Typesystem.hpp>
#include <core/model/RootNode.hpp>
diff --git a/src/core/parser/stack/DocumentHandler.cpp b/src/core/parser/stack/DocumentHandler.cpp
index e931d8d..26b9b6e 100644
--- a/src/core/parser/stack/DocumentHandler.cpp
+++ b/src/core/parser/stack/DocumentHandler.cpp
@@ -22,7 +22,7 @@
#include <core/common/Utils.hpp>
#include <core/common/VariantReader.hpp>
#include <core/model/Document.hpp>
-#include <core/model/Domain.hpp>
+#include <core/model/Ontology.hpp>
#include <core/model/Project.hpp>
#include <core/model/Typesystem.hpp>
#include <core/parser/utils/TokenizedData.hpp>
@@ -234,7 +234,7 @@ bool DocumentChildHandler::startCommand(Variant::mapType &args)
throw LoggableException(
std::string("An instance of \"") + strct->getName() +
"\" is not allowed as child of field \"" +
- field->getName() + "\" of descriptor \"" +
+ field->getNameOrDefaultName() + "\" of descriptor \"" +
parent->getDescriptor()->getName() + "\"",
location());
}
diff --git a/src/core/parser/stack/DocumentHandler.hpp b/src/core/parser/stack/DocumentHandler.hpp
index d34c020..0e35558 100644
--- a/src/core/parser/stack/DocumentHandler.hpp
+++ b/src/core/parser/stack/DocumentHandler.hpp
@@ -46,7 +46,7 @@ namespace parser_stack {
/**
* The DocumentHandler class parses the "document" tag that is used to introduce
* a new document. Note that this tag is not mandatory in osml files -- if the
- * first command is not a typesystem, domain or any other declarative command,
+ * first command is not a typesystem, ontology or any other declarative command,
* the DocumentHandler will be implicitly called.
*/
class DocumentHandler : public StaticHandler {
diff --git a/src/core/parser/stack/GenericParserStates.cpp b/src/core/parser/stack/GenericParserStates.cpp
index 69a6e0e..7287524 100644
--- a/src/core/parser/stack/GenericParserStates.cpp
+++ b/src/core/parser/stack/GenericParserStates.cpp
@@ -17,7 +17,7 @@
*/
#include "DocumentHandler.hpp"
-#include "DomainHandler.hpp"
+#include "OntologyHandler.hpp"
#include "GenericParserStates.hpp"
#include "ImportIncludeHandler.hpp"
#include "TypesystemHandler.hpp"
@@ -28,18 +28,18 @@ namespace parser_stack {
const std::multimap<std::string, const State *> GenericParserStates{
{"document", &States::Document},
{"*", &States::DocumentChild},
- {"domain", &States::Domain},
- {"struct", &States::DomainStruct},
- {"annotation", &States::DomainAnnotation},
- {"attributes", &States::DomainAttributes},
- {"attribute", &States::DomainAttribute},
- {"field", &States::DomainField},
- {"fieldRef", &States::DomainFieldRef},
- {"primitive", &States::DomainStructPrimitive},
- {"childRef", &States::DomainStructChild},
- {"parentRef", &States::DomainStructParent},
- {"field", &States::DomainStructParentField},
- {"fieldRef", &States::DomainStructParentFieldRef},
+ {"ontology", &States::Ontology},
+ {"struct", &States::OntologyStruct},
+ {"annotation", &States::OntologyAnnotation},
+ {"attributes", &States::OntologyAttributes},
+ {"attribute", &States::OntologyAttribute},
+ {"field", &States::OntologyField},
+ {"fieldRef", &States::OntologyFieldRef},
+ {"primitive", &States::OntologyStructPrimitive},
+ {"childRef", &States::OntologyStructChild},
+ {"parentRef", &States::OntologyStructParent},
+ {"field", &States::OntologyStructParentField},
+ {"fieldRef", &States::OntologyStructParentFieldRef},
{"typesystem", &States::Typesystem},
{"enum", &States::TypesystemEnum},
{"entry", &States::TypesystemEnumEntry},
diff --git a/src/core/parser/stack/ImportIncludeHandler.cpp b/src/core/parser/stack/ImportIncludeHandler.cpp
index d1ea97d..a6cbaea 100644
--- a/src/core/parser/stack/ImportIncludeHandler.cpp
+++ b/src/core/parser/stack/ImportIncludeHandler.cpp
@@ -20,7 +20,7 @@
#include <core/parser/ParserScope.hpp>
#include <core/parser/ParserContext.hpp>
-#include "DomainHandler.hpp"
+#include "OntologyHandler.hpp"
#include "DocumentHandler.hpp"
#include "ImportIncludeHandler.hpp"
#include "State.hpp"
@@ -38,7 +38,7 @@ void ImportHandler::doHandle(const Variant &fieldData, Variant::mapType &args)
Rooted<Node> leaf = scope().getLeaf();
if (leaf == nullptr || !leaf->isa(&RttiTypes::RootNode)) {
logger().error(
- "Import not supported here, must be inside a document, domain "
+ "Import not supported here, must be inside a document, ontology "
"or typesystem command.",
location());
return;
@@ -66,7 +66,7 @@ void IncludeHandler::doHandle(const Variant &fieldData, Variant::mapType &args)
namespace States {
const State Import =
StateBuilder()
- .parents({&Document, &Typesystem, &Domain})
+ .parents({&Document, &Typesystem, &Ontology})
.elementHandler(ImportHandler::create)
.arguments({Argument::String("rel", ""), Argument::String("type", ""),
Argument::String("src", "")});
diff --git a/src/core/parser/stack/DomainHandler.cpp b/src/core/parser/stack/OntologyHandler.cpp
index aef5b47..3b3b386 100644
--- a/src/core/parser/stack/DomainHandler.cpp
+++ b/src/core/parser/stack/OntologyHandler.cpp
@@ -18,52 +18,52 @@
#include <core/common/RttiBuilder.hpp>
#include <core/model/Document.hpp>
-#include <core/model/Domain.hpp>
+#include <core/model/Ontology.hpp>
#include <core/model/Project.hpp>
#include <core/parser/ParserScope.hpp>
#include <core/parser/ParserContext.hpp>
#include "DocumentHandler.hpp"
-#include "DomainHandler.hpp"
+#include "OntologyHandler.hpp"
#include "State.hpp"
#include "TypesystemHandler.hpp"
namespace ousia {
namespace parser_stack {
-/* DomainHandler */
+/* OntologyHandler */
bool DomainHandler::startCommand(Variant::mapType &args)
{
- // Create the Domain node
- Rooted<Domain> domain =
- context().getProject()->createDomain(args["name"].asString());
- domain->setLocation(location());
+ // Create the Ontology node
+ Rooted<Ontology> ontology =
+ context().getProject()->createOntology(args["name"].asString());
+ ontology->setLocation(location());
- // If the domain is defined inside a document, add the reference to the
+ // If the ontology is defined inside a document, add the reference to the
// document
Rooted<Document> document = scope().select<Document>();
if (document != nullptr) {
- document->reference(domain);
+ document->reference(ontology);
}
// Push the typesystem onto the scope, set the POST_HEAD flag to true
- scope().push(domain);
+ scope().push(ontology);
scope().setFlag(ParserFlag::POST_HEAD, false);
return true;
}
-void DomainHandler::end() { scope().pop(logger()); }
+void OntologyHandler::end() { scope().pop(logger()); }
-/* DomainStructHandler */
+/* OntologyStructHandler */
-bool DomainStructHandler::startCommand(Variant::mapType &args)
+bool OntologyStructHandler::start(Variant::mapType &args)
{
scope().setFlag(ParserFlag::POST_HEAD, true);
- Rooted<Domain> domain = scope().selectOrThrow<Domain>();
+ Rooted<Ontology> ontology = scope().selectOrThrow<Ontology>();
- Rooted<StructuredClass> structuredClass = domain->createStructuredClass(
+ Rooted<StructuredClass> structuredClass = ontology->createStructuredClass(
args["name"].asString(), args["cardinality"].asCardinality(), nullptr,
args["transparent"].asBool(), args["isRoot"].asBool());
structuredClass->setLocation(location());
@@ -85,28 +85,28 @@ bool DomainStructHandler::startCommand(Variant::mapType &args)
return true;
}
-void DomainStructHandler::end() { scope().pop(logger()); }
+void OntologyStructHandler::end() { scope().pop(logger()); }
-/* DomainAnnotationHandler */
-bool DomainAnnotationHandler::startCommand(Variant::mapType &args)
+/* OntologyAnnotationHandler */
+bool OntologyAnnotationHandler::start(Variant::mapType &args)
{
scope().setFlag(ParserFlag::POST_HEAD, true);
- Rooted<Domain> domain = scope().selectOrThrow<Domain>();
+ Rooted<Ontology> ontology = scope().selectOrThrow<Ontology>();
Rooted<AnnotationClass> annotationClass =
- domain->createAnnotationClass(args["name"].asString());
+ ontology->createAnnotationClass(args["name"].asString());
annotationClass->setLocation(location());
scope().push(annotationClass);
return true;
}
-void DomainAnnotationHandler::end() { scope().pop(logger()); }
+void OntologyAnnotationHandler::end() { scope().pop(logger()); }
-/* DomainAttributesHandler */
+/* OntologyAttributesHandler */
-bool DomainAttributesHandler::startCommand(Variant::mapType &args)
+bool OntologyAttributesHandler::start(Variant::mapType &args)
{
// Fetch the current typesystem and create the struct node
Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
@@ -118,11 +118,11 @@ bool DomainAttributesHandler::startCommand(Variant::mapType &args)
return true;
}
-void DomainAttributesHandler::end() { scope().pop(logger()); }
+void OntologyAttributesHandler::end() { scope().pop(logger()); }
-/* DomainFieldHandler */
+/* OntologyFieldHandler */
-bool DomainFieldHandler::startCommand(Variant::mapType &args)
+bool OntologyFieldHandler::start(Variant::mapType &args)
{
FieldDescriptor::FieldType type;
if (args["isSubtree"].asBool()) {
@@ -148,11 +148,11 @@ bool DomainFieldHandler::startCommand(Variant::mapType &args)
return true;
}
-void DomainFieldHandler::end() { scope().pop(logger()); }
+void OntologyFieldHandler::end() { scope().pop(logger()); }
-/* DomainFieldRefHandler */
+/* OntologyFieldRefHandler */
-bool DomainFieldRefHandler::startCommand(Variant::mapType &args)
+bool OntologyFieldRefHandler::start(Variant::mapType &args)
{
Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
@@ -178,11 +178,11 @@ bool DomainFieldRefHandler::startCommand(Variant::mapType &args)
return true;
}
-void DomainFieldRefHandler::end() {}
+void OntologyFieldRefHandler::end() {}
-/* DomainPrimitiveHandler */
+/* OntologyPrimitiveHandler */
-bool DomainPrimitiveHandler::startCommand(Variant::mapType &args)
+bool OntologyPrimitiveHandler::start(Variant::mapType &args)
{
Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
@@ -206,7 +206,7 @@ bool DomainPrimitiveHandler::startCommand(Variant::mapType &args)
}
const std::string &type = args["type"].asString();
- scope().resolve<Type>(type, res.first, logger(),
+ scope().resolveType(type, res.first, logger(),
[](Handle<Node> type, Handle<Node> field,
Logger &logger) {
if (type != nullptr) {
@@ -218,11 +218,11 @@ bool DomainPrimitiveHandler::startCommand(Variant::mapType &args)
return true;
}
-void DomainPrimitiveHandler::end() { scope().pop(logger()); }
+void OntologyPrimitiveHandler::end() { scope().pop(logger()); }
-/* DomainChildHandler */
+/* OntologyChildHandler */
-bool DomainChildHandler::startCommand(Variant::mapType &args)
+bool OntologyChildHandler::start(Variant::mapType &args)
{
Rooted<FieldDescriptor> field = scope().selectOrThrow<FieldDescriptor>();
@@ -238,26 +238,26 @@ bool DomainChildHandler::startCommand(Variant::mapType &args)
return true;
}
-/* DomainParentHandler */
+/* OntologyParentHandler */
-bool DomainParentHandler::startCommand(Variant::mapType &args)
+bool OntologyParentHandler::start(Variant::mapType &args)
{
Rooted<StructuredClass> strct = scope().selectOrThrow<StructuredClass>();
- Rooted<DomainParent> parent{
- new DomainParent(strct->getManager(), args["ref"].asString(), strct)};
+ Rooted<OntologyParent> parent{
+ new OntologyParent(strct->getManager(), args["ref"].asString(), strct)};
parent->setLocation(location());
scope().push(parent);
return true;
}
-void DomainParentHandler::end() { scope().pop(logger()); }
+void OntologyParentHandler::end() { scope().pop(logger()); }
-/* DomainParentFieldHandler */
+/* OntologyParentFieldHandler */
-bool DomainParentFieldHandler::startCommand(Variant::mapType &args)
+bool OntologyParentFieldHandler::start(Variant::mapType &args)
{
- Rooted<DomainParent> parentNameNode = scope().selectOrThrow<DomainParent>();
+ Rooted<OntologyParent> parentNameNode = scope().selectOrThrow<OntologyParent>();
FieldDescriptor::FieldType type;
if (args["isSubtree"].asBool()) {
type = FieldDescriptor::FieldType::SUBTREE;
@@ -286,11 +286,11 @@ bool DomainParentFieldHandler::startCommand(Variant::mapType &args)
return true;
}
-/* DomainParentFieldRefHandler */
+/* OntologyParentFieldRefHandler */
-bool DomainParentFieldRefHandler::startCommand(Variant::mapType &args)
+bool OntologyParentFieldRefHandler::start(Variant::mapType &args)
{
- Rooted<DomainParent> parentNameNode = scope().selectOrThrow<DomainParent>();
+ Rooted<OntologyParent> parentNameNode = scope().selectOrThrow<OntologyParent>();
const std::string &name = args["ref"].asString();
Rooted<StructuredClass> strct =
@@ -317,100 +317,100 @@ bool DomainParentFieldRefHandler::startCommand(Variant::mapType &args)
}
namespace States {
-const State Domain = StateBuilder()
+const State Ontology = StateBuilder()
.parents({&None, &Document})
- .createdNodeType(&RttiTypes::Domain)
- .elementHandler(DomainHandler::create)
+ .createdNodeType(&RttiTypes::Ontology)
+ .elementHandler(OntologyHandler::create)
.arguments({Argument::String("name")});
-const State DomainStruct =
+const State OntologyStruct =
StateBuilder()
- .parent(&Domain)
+ .parent(&Ontology)
.createdNodeType(&RttiTypes::StructuredClass)
- .elementHandler(DomainStructHandler::create)
+ .elementHandler(OntologyStructHandler::create)
.arguments({Argument::String("name"),
Argument::Cardinality("cardinality", Cardinality::any()),
Argument::Bool("isRoot", false),
Argument::Bool("transparent", false),
Argument::String("isa", "")});
-const State DomainAnnotation =
+const State OntologyAnnotation =
StateBuilder()
- .parent(&Domain)
+ .parent(&Ontology)
.createdNodeType(&RttiTypes::AnnotationClass)
- .elementHandler(DomainAnnotationHandler::create)
+ .elementHandler(OntologyAnnotationHandler::create)
.arguments({Argument::String("name")});
-const State DomainAttributes =
+const State OntologyAttributes =
StateBuilder()
- .parents({&DomainStruct, &DomainAnnotation})
+ .parents({&OntologyStruct, &OntologyAnnotation})
.createdNodeType(&RttiTypes::StructType)
- .elementHandler(DomainAttributesHandler::create)
+ .elementHandler(OntologyAttributesHandler::create)
.arguments({});
-const State DomainAttribute =
+const State OntologyAttribute =
StateBuilder()
- .parent(&DomainAttributes)
+ .parent(&OntologyAttributes)
.elementHandler(TypesystemStructFieldHandler::create)
.arguments({Argument::String("name"), Argument::String("type"),
Argument::Any("default", Variant::fromObject(nullptr))});
-const State DomainField = StateBuilder()
- .parents({&DomainStruct, &DomainAnnotation})
+const State OntologyField = StateBuilder()
+ .parents({&OntologyStruct, &OntologyAnnotation})
.createdNodeType(&RttiTypes::FieldDescriptor)
- .elementHandler(DomainFieldHandler::create)
+ .elementHandler(OntologyFieldHandler::create)
.arguments({Argument::String("name", ""),
Argument::Bool("isSubtree", false),
Argument::Bool("optional", false)});
-const State DomainFieldRef =
+const State OntologyFieldRef =
StateBuilder()
- .parents({&DomainStruct, &DomainAnnotation})
+ .parents({&OntologyStruct, &OntologyAnnotation})
.createdNodeType(&RttiTypes::FieldDescriptor)
- .elementHandler(DomainFieldRefHandler::create)
+ .elementHandler(OntologyFieldRefHandler::create)
.arguments({Argument::String("ref", DEFAULT_FIELD_NAME)});
-const State DomainStructPrimitive =
+const State OntologyStructPrimitive =
StateBuilder()
- .parents({&DomainStruct, &DomainAnnotation})
+ .parents({&OntologyStruct, &OntologyAnnotation})
.createdNodeType(&RttiTypes::FieldDescriptor)
- .elementHandler(DomainPrimitiveHandler::create)
+ .elementHandler(OntologyPrimitiveHandler::create)
.arguments(
{Argument::String("name", ""), Argument::Bool("isSubtree", false),
Argument::Bool("optional", false), Argument::String("type")});
-const State DomainStructChild = StateBuilder()
- .parent(&DomainField)
- .elementHandler(DomainChildHandler::create)
+const State OntologyStructChild = StateBuilder()
+ .parent(&OntologyField)
+ .elementHandler(OntologyChildHandler::create)
.arguments({Argument::String("ref")});
-const State DomainStructParent =
+const State OntologyStructParent =
StateBuilder()
- .parent(&DomainStruct)
- .createdNodeType(&RttiTypes::DomainParent)
- .elementHandler(DomainParentHandler::create)
+ .parent(&OntologyStruct)
+ .createdNodeType(&RttiTypes::OntologyParent)
+ .elementHandler(OntologyParentHandler::create)
.arguments({Argument::String("ref")});
-const State DomainStructParentField =
+const State OntologyStructParentField =
StateBuilder()
- .parent(&DomainStructParent)
+ .parent(&OntologyStructParent)
.createdNodeType(&RttiTypes::FieldDescriptor)
- .elementHandler(DomainParentFieldHandler::create)
+ .elementHandler(OntologyParentFieldHandler::create)
.arguments({Argument::String("name", ""),
Argument::Bool("isSubtree", false),
Argument::Bool("optional", false)});
-const State DomainStructParentFieldRef =
+const State OntologyStructParentFieldRef =
StateBuilder()
- .parent(&DomainStructParent)
+ .parent(&OntologyStructParent)
.createdNodeType(&RttiTypes::FieldDescriptor)
- .elementHandler(DomainParentFieldRefHandler::create)
+ .elementHandler(OntologyParentFieldRefHandler::create)
.arguments({Argument::String("ref", DEFAULT_FIELD_NAME)});
}
}
namespace RttiTypes {
-const Rtti DomainParent = RttiBuilder<ousia::parser_stack::DomainParent>(
- "DomainParent").parent(&Node);
+const Rtti OntologyParent = RttiBuilder<ousia::parser_stack::OntologyParent>(
+ "OntologyParent").parent(&Node);
}
}
diff --git a/src/core/parser/stack/DomainHandler.hpp b/src/core/parser/stack/OntologyHandler.hpp
index f12d863..66146bd 100644
--- a/src/core/parser/stack/DomainHandler.hpp
+++ b/src/core/parser/stack/OntologyHandler.hpp
@@ -17,10 +17,10 @@
*/
/**
- * @file DomainHandler.hpp
+ * @file OntologyHandler.hpp
*
- * Contains the Handler classes used for parsing Domain descriptors. This
- * includes the "domain" tag and all describing tags below the "domain" tag.
+ * Contains the Handler classes used for parsing Ontology descriptors. This
+ * includes the "ontology" tag and all describing tags below the "ontology" tag.
*
* @author Benjamin Paaßen (bpaassen@techfak.uni-bielefeld.de)
*/
@@ -42,7 +42,7 @@ namespace parser_stack {
// TODO: Documentation
-class DomainHandler : public StaticHandler {
+class OntologyHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -51,11 +51,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainHandler{handlerData};
+ return new OntologyHandler{handlerData};
}
};
-class DomainStructHandler : public StaticHandler {
+class OntologyStructHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -64,11 +64,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainStructHandler{handlerData};
+ return new OntologyStructHandler{handlerData};
}
};
-class DomainAnnotationHandler : public StaticHandler {
+class OntologyAnnotationHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -77,11 +77,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainAnnotationHandler{handlerData};
+ return new OntologyAnnotationHandler{handlerData};
}
};
-class DomainAttributesHandler : public StaticHandler {
+class OntologyAttributesHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -90,11 +90,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainAttributesHandler{handlerData};
+ return new OntologyAttributesHandler{handlerData};
}
};
-class DomainFieldHandler : public StaticHandler {
+class OntologyFieldHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -103,11 +103,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainFieldHandler{handlerData};
+ return new OntologyFieldHandler{handlerData};
}
};
-class DomainFieldRefHandler : public StaticHandler {
+class OntologyFieldRefHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -116,11 +116,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainFieldRefHandler{handlerData};
+ return new OntologyFieldRefHandler{handlerData};
}
};
-class DomainPrimitiveHandler : public StaticHandler {
+class OntologyPrimitiveHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -129,11 +129,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainPrimitiveHandler{handlerData};
+ return new OntologyPrimitiveHandler{handlerData};
}
};
-class DomainChildHandler : public StaticHandler {
+class OntologyChildHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -141,16 +141,16 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainChildHandler{handlerData};
+ return new OntologyChildHandler{handlerData};
}
};
-class DomainParent : public Node {
+class OntologyParent : public Node {
public:
using Node::Node;
};
-class DomainParentHandler : public StaticHandler {
+class OntologyParentHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -159,11 +159,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainParentHandler{handlerData};
+ return new OntologyParentHandler{handlerData};
}
};
-class DomainParentFieldHandler : public StaticHandler {
+class OntologyParentFieldHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -171,11 +171,11 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainParentFieldHandler{handlerData};
+ return new OntologyParentFieldHandler{handlerData};
}
};
-class DomainParentFieldRefHandler : public StaticHandler {
+class OntologyParentFieldRefHandler : public StaticHandler {
public:
using StaticHandler::StaticHandler;
@@ -183,75 +183,75 @@ public:
static Handler *create(const HandlerData &handlerData)
{
- return new DomainParentFieldRefHandler{handlerData};
+ return new OntologyParentFieldRefHandler{handlerData};
}
};
namespace States {
/**
- * State representing a "domain" struct.
+ * State representing a "ontology" struct.
*/
-extern const State Domain;
+extern const State Ontology;
/**
- * State representing a "struct" tag within a domain description.
+ * State representing a "struct" tag within a ontology description.
*/
-extern const State DomainStruct;
+extern const State OntologyStruct;
/**
- * State representing an "annotation" tag within a domain description.
+ * State representing an "annotation" tag within a ontology description.
*/
-extern const State DomainAnnotation;
+extern const State OntologyAnnotation;
/**
* State representing an "attributes" tag within a structure or annotation.
*/
-extern const State DomainAttributes;
+extern const State OntologyAttributes;
/**
* State representing an "attribute" tag within the "attributes".
*/
-extern const State DomainAttribute;
+extern const State OntologyAttribute;
/**
* State representing a "field" tag within a structure or annotation.
*/
-extern const State DomainField;
+extern const State OntologyField;
/**
* State representing a "fieldref" tag within a structure or annotation.
*/
-extern const State DomainFieldRef;
+extern const State OntologyFieldRef;
/**
* State representing a "primitive" tag within a structure or annotation.
*/
-extern const State DomainStructPrimitive;
+extern const State OntologyStructPrimitive;
/**
* State representing a "child" tag within a structure or annotation.
*/
-extern const State DomainStructChild;
+extern const State OntologyStructChild;
/**
* State representing a "parent" tag within a structure or annotation.
*/
-extern const State DomainStructParent;
+extern const State OntologyStructParent;
/**
* State representing a "field" tag within a "parent" tag.
*/
-extern const State DomainStructParentField;
+extern const State OntologyStructParentField;
/**
* State representing a "fieldRef" tag within a "parent" tag.
*/
-extern const State DomainStructParentFieldRef;
+extern const State OntologyStructParentFieldRef;
}
}
namespace RttiTypes {
-extern const Rtti DomainParent;
+extern const Rtti OntologyParent;
}
}
#endif
diff --git a/src/core/parser/stack/TypesystemHandler.cpp b/src/core/parser/stack/TypesystemHandler.cpp
index 3fa641a..73bcf62 100644
--- a/src/core/parser/stack/TypesystemHandler.cpp
+++ b/src/core/parser/stack/TypesystemHandler.cpp
@@ -17,13 +17,13 @@
*/
#include <core/model/Document.hpp>
-#include <core/model/Domain.hpp>
+#include <core/model/Ontology.hpp>
#include <core/model/Typesystem.hpp>
#include <core/parser/ParserScope.hpp>
#include <core/parser/ParserContext.hpp>
#include "DocumentHandler.hpp"
-#include "DomainHandler.hpp"
+#include "OntologyHandler.hpp"
#include "State.hpp"
#include "TypesystemHandler.hpp"
@@ -39,12 +39,12 @@ bool TypesystemHandler::startCommand(Variant::mapType &args)
context().getProject()->createTypesystem(args["name"].asString());
typesystem->setLocation(location());
- // If the typesystem is defined inside a domain, add a reference to the
- // typesystem to the domain -- do the same with a document, if no domain
+ // If the typesystem is defined inside a ontology, add a reference to the
+ // typesystem to the ontology -- do the same with a document, if no ontology
// is found
- Rooted<Domain> domain = scope().select<Domain>();
- if (domain != nullptr) {
- domain->reference(typesystem);
+ Rooted<Ontology> ontology = scope().select<Ontology>();
+ if (ontology != nullptr) {
+ ontology->reference(typesystem);
} else {
Rooted<Document> document = scope().select<Document>();
if (document != nullptr) {
@@ -190,7 +190,7 @@ bool TypesystemConstantHandler::startCommand(Variant::mapType &args)
namespace States {
const State Typesystem = StateBuilder()
- .parents({&None, &Domain, &Document})
+ .parents({&None, &Ontology, &Document})
.createdNodeType(&RttiTypes::Typesystem)
.elementHandler(TypesystemHandler::create)
.arguments({Argument::String("name", "")});
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-04 10:20:02 +0000