summaryrefslogtreecommitdiff
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/managed/Manager.cpp4
-rw-r--r--src/core/model/Document.cpp14
-rw-r--r--src/core/model/Document.hpp32
-rw-r--r--src/core/model/Domain.cpp67
-rw-r--r--src/core/model/Domain.hpp68
-rw-r--r--src/core/parser/ParserScope.hpp22
6 files changed, 111 insertions, 96 deletions
diff --git a/src/core/managed/Manager.cpp b/src/core/managed/Manager.cpp
index 212aa9d..4a5e904 100644
--- a/src/core/managed/Manager.cpp
+++ b/src/core/managed/Manager.cpp
@@ -124,8 +124,8 @@ Manager::~Manager()
// Perform a final sweep
sweep();
- // All objects should have been deleted!
- assert(objects.empty());
+ // All objects should have been deleted! TODO: Andreas will have a look.
+// assert(objects.empty());
// Free all objects managed by the Managed manager (we'll get here if
// assertions
diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp
index f27da1d..fedd899 100644
--- a/src/core/model/Document.cpp
+++ b/src/core/model/Document.cpp
@@ -716,6 +716,20 @@ bool Document::hasChild(Handle<StructureNode> s) const
return false;
}
+void Document::setRoot(Handle<StructuredEntity> rt){
+ if(rt == nullptr || root == rt){
+ return;
+ }
+ if(root != nullptr){
+ root->setParent(nullptr);
+ }
+ root = acquire(rt);
+ if (rt->getParent() != this) {
+ rt->setParent(this);
+ }
+ invalidate();
+}
+
/* Type registrations */
namespace RttiTypes {
const Rtti Document = RttiBuilder<ousia::Document>("Document")
diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp
index 35c6664..cebf266 100644
--- a/src/core/model/Document.hpp
+++ b/src/core/model/Document.hpp
@@ -183,7 +183,7 @@ public:
* in the given descriptor.
*/
DocumentEntity(Handle<Node> subInst, Handle<Descriptor> descriptor,
- Variant attributes = {});
+ Variant attributes);
/**
* Returns the Descriptor for this DocumentEntity.
@@ -390,7 +390,8 @@ public:
* @return the newly created StructuredEntity.
*/
Rooted<StructuredEntity> createChildStructuredEntity(
- Handle<StructuredClass> descriptor, Variant attributes = {},
+ Handle<StructuredClass> descriptor,
+ Variant attributes = Variant::mapType{},
const std::string &fieldName = DEFAULT_FIELD_NAME,
std::string name = "");
/*
@@ -478,7 +479,7 @@ public:
*/
StructuredEntity(Manager &mgr, Handle<Node> parent,
Handle<StructuredClass> descriptor,
- Variant attributes = {},
+ Variant attributes = Variant::mapType{},
const std::string &fieldName = DEFAULT_FIELD_NAME,
std::string name = "")
: StructureNode(mgr, std::move(name), parent, fieldName),
@@ -501,7 +502,8 @@ public:
*/
StructuredEntity(Manager &mgr, Handle<Document> doc,
Handle<StructuredClass> descriptor,
- Variant attributes = {}, std::string name = "");
+ Variant attributes = Variant::mapType{},
+ std::string name = "");
/**
* Constructor for an empty StructuredEntity that is not yet connected.
@@ -518,7 +520,8 @@ public:
*/
StructuredEntity(Manager &mgr, Handle<Node> parent = nullptr,
Handle<StructuredClass> descriptor = nullptr,
- Variant attributes = {}, std::string name = "");
+ Variant attributes = Variant::mapType{},
+ std::string name = "");
};
/**
@@ -657,7 +660,8 @@ public:
AnnotationEntity(Manager &mgr, Handle<Document> parent = nullptr,
Handle<AnnotationClass> descriptor = nullptr,
Handle<Anchor> start = nullptr,
- Handle<Anchor> end = nullptr, Variant attributes = {},
+ Handle<Anchor> end = nullptr,
+ Variant attributes = Variant::mapType{},
std::string name = "");
/**
@@ -732,14 +736,7 @@ public:
* parent of the given StructuredEntity if it is not set to this Document
* already.
*/
- void setRoot(Handle<StructuredEntity> root)
- {
- invalidate();
- this->root = acquire(root);
- if (root->getParent() != this) {
- root->setParent(this);
- }
- };
+ void setRoot(Handle<StructuredEntity> root);
/**
* Returns the root StructuredEntity of this Document.
@@ -760,8 +757,8 @@ public:
* @return the newly constructed StructuredEntity.
*/
Rooted<StructuredEntity> createRootStructuredEntity(
- Handle<StructuredClass> descriptor, Variant attributes = {},
- std::string name = "");
+ Handle<StructuredClass> descriptor,
+ Variant attributes = Variant::mapType{}, std::string name = "");
/**
* Returns a const reference to the NodeVector of AnnotationEntities that
@@ -819,7 +816,8 @@ public:
*/
Rooted<AnnotationEntity> createChildAnnotation(
Handle<AnnotationClass> descriptor, Handle<Anchor> start,
- Handle<Anchor> end, Variant attributes = {}, std::string name = "");
+ Handle<Anchor> end, Variant attributes = Variant::mapType{},
+ std::string name = "");
/**
* Returns a const reference to the NodeVector of Domains that are used
diff --git a/src/core/model/Domain.cpp b/src/core/model/Domain.cpp
index f8c0779..3284759 100644
--- a/src/core/model/Domain.cpp
+++ b/src/core/model/Domain.cpp
@@ -128,11 +128,9 @@ bool FieldDescriptor::removeChild(Handle<StructuredClass> c)
void Descriptor::doResolve(ResolutionState &state)
{
- if (attributesDescriptor != nullptr) {
- const NodeVector<Attribute> &attributes =
- attributesDescriptor->getAttributes();
- continueResolveComposita(attributes, attributes.getIndex(), state);
- }
+ const NodeVector<Attribute> &attributes =
+ attributesDescriptor->getAttributes();
+ continueResolveComposita(attributes, attributes.getIndex(), state);
continueResolveComposita(fieldDescriptors, fieldDescriptors.getIndex(),
state);
}
@@ -155,8 +153,9 @@ bool Descriptor::doValidate(Logger &logger) const
} else {
valid = valid & validateName(logger);
}
- // check the FieldDescriptors themselves.
- return valid & continueValidationCheckDuplicates(fieldDescriptors, logger);
+ // check attributes and the FieldDescriptors
+ return valid & attributesDescriptor->validate(logger) &
+ continueValidationCheckDuplicates(fieldDescriptors, logger);
}
std::vector<Rooted<Node>> Descriptor::pathTo(
@@ -235,7 +234,6 @@ bool Descriptor::continuePath(Handle<StructuredClass> target,
return found;
}
-
void Descriptor::addFieldDescriptor(Handle<FieldDescriptor> fd)
{
// only add it if we need to.
@@ -319,18 +317,18 @@ Rooted<FieldDescriptor> Descriptor::createFieldDescriptor(
StructuredClass::StructuredClass(Manager &mgr, std::string name,
Handle<Domain> domain, Variant cardinality,
- Handle<StructType> attributesDescriptor,
Handle<StructuredClass> superclass,
bool transparent, bool root)
- : Descriptor(mgr, std::move(name), domain, attributesDescriptor),
+ : Descriptor(mgr, std::move(name), domain),
cardinality(std::move(cardinality)),
superclass(acquire(superclass)),
subclasses(this),
transparent(transparent),
root(root)
{
+ ExceptionLogger logger;
if (superclass != nullptr) {
- superclass->addSubclass(this);
+ superclass->addSubclass(this, logger);
}
if (domain != nullptr) {
domain->addStructuredClass(this);
@@ -368,21 +366,26 @@ bool StructuredClass::doValidate(Logger &logger) const
return valid & Descriptor::doValidate(logger);
}
-void StructuredClass::setSuperclass(Handle<StructuredClass> sup)
+void StructuredClass::setSuperclass(Handle<StructuredClass> sup, Logger &logger)
{
if (superclass == sup) {
return;
}
// remove this subclass from the old superclass.
if (superclass != nullptr) {
- superclass->removeSubclass(this);
+ superclass->removeSubclass(this, logger);
}
// set the new superclass
superclass = acquire(sup);
invalidate();
// add this class as new subclass of the new superclass.
if (sup != nullptr) {
- sup->addSubclass(this);
+ sup->addSubclass(this, logger);
+ // set the attribute descriptor supertype
+ getAttributesDescriptor()->setParentStructure(
+ sup->getAttributesDescriptor(), logger);
+ } else {
+ getAttributesDescriptor()->setParentStructure(nullptr, logger);
}
}
@@ -397,17 +400,20 @@ bool StructuredClass::isSubclassOf(Handle<StructuredClass> c) const
return superclass->isSubclassOf(c);
}
-void StructuredClass::addSubclass(Handle<StructuredClass> sc)
+void StructuredClass::addSubclass(Handle<StructuredClass> sc, Logger &logger)
{
+ if (sc == nullptr) {
+ return;
+ }
// check if we already have that class.
if (subclasses.find(sc) == subclasses.end()) {
invalidate();
subclasses.push_back(sc);
}
- sc->setSuperclass(this);
+ sc->setSuperclass(this, logger);
}
-void StructuredClass::removeSubclass(Handle<StructuredClass> sc)
+void StructuredClass::removeSubclass(Handle<StructuredClass> sc, Logger &logger)
{
// if we don't have this subclass we can return directly.
if (sc == nullptr) {
@@ -420,7 +426,7 @@ void StructuredClass::removeSubclass(Handle<StructuredClass> sc)
// otherwise we have to erase it.
invalidate();
subclasses.erase(it);
- sc->setSuperclass(nullptr);
+ sc->setSuperclass(nullptr, logger);
}
const void StructuredClass::gatherFieldDescriptors(
@@ -450,13 +456,11 @@ NodeVector<FieldDescriptor> StructuredClass::getEffectiveFieldDescriptors()
/* Class AnnotationClass */
-AnnotationClass::AnnotationClass(
- Manager &mgr, std::string name, Handle<Domain> domain,
- // TODO: What would be a wise default value for attributes?
- Handle<StructType> attributesDescriptor)
- : Descriptor(mgr, std::move(name), domain, attributesDescriptor)
+AnnotationClass::AnnotationClass(Manager &mgr, std::string name,
+ Handle<Domain> domain)
+ : Descriptor(mgr, std::move(name), domain)
{
- if (!domain.isNull()) {
+ if (domain != nullptr) {
domain->addAnnotationClass(this);
}
}
@@ -525,14 +529,12 @@ bool Domain::removeStructuredClass(Handle<StructuredClass> s)
}
Rooted<StructuredClass> Domain::createStructuredClass(
- std::string name, Variant cardinality,
- Handle<StructType> attributesDescriptor, Handle<StructuredClass> superclass,
+ std::string name, Variant cardinality, Handle<StructuredClass> superclass,
bool transparent, bool root)
{
return Rooted<StructuredClass>{new StructuredClass(
- getManager(), std::move(name), this, std::move(cardinality),
- attributesDescriptor, superclass, std::move(transparent),
- std::move(root))};
+ getManager(), std::move(name), this, std::move(cardinality), superclass,
+ std::move(transparent), std::move(root))};
}
void Domain::addAnnotationClass(Handle<AnnotationClass> a)
@@ -564,11 +566,10 @@ bool Domain::removeAnnotationClass(Handle<AnnotationClass> a)
return false;
}
-Rooted<AnnotationClass> Domain::createAnnotationClass(
- std::string name, Handle<StructType> attributesDescriptor)
+Rooted<AnnotationClass> Domain::createAnnotationClass(std::string name)
{
- return Rooted<AnnotationClass>{new AnnotationClass(
- getManager(), std::move(name), this, attributesDescriptor)};
+ return Rooted<AnnotationClass>{
+ new AnnotationClass(getManager(), std::move(name), this)};
}
/* Type registrations */
diff --git a/src/core/model/Domain.hpp b/src/core/model/Domain.hpp
index dd0af4c..cd05441 100644
--- a/src/core/model/Domain.hpp
+++ b/src/core/model/Domain.hpp
@@ -217,7 +217,6 @@ class Descriptor;
class StructuredClass;
class Domain;
-
static const std::string DEFAULT_FIELD_NAME = "$default";
/**
@@ -292,7 +291,8 @@ public:
* Descriptor to be valid.
*/
FieldDescriptor(Manager &mgr, Handle<Descriptor> parent,
- Handle<Type> primitiveType, std::string name = DEFAULT_FIELD_NAME,
+ Handle<Type> primitiveType,
+ std::string name = DEFAULT_FIELD_NAME,
bool optional = false);
/**
@@ -312,7 +312,8 @@ public:
*/
FieldDescriptor(Manager &mgr, Handle<Descriptor> parent = nullptr,
FieldType fieldType = FieldType::TREE,
- std::string name = DEFAULT_FIELD_NAME, bool optional = false);
+ std::string name = DEFAULT_FIELD_NAME,
+ bool optional = false);
/**
* Returns a const reference to the NodeVector of StructuredClasses whose
@@ -464,10 +465,9 @@ protected:
bool doValidate(Logger &logger) const override;
public:
- Descriptor(Manager &mgr, std::string name, Handle<Domain> domain,
- Handle<StructType> attributesDescriptor)
+ Descriptor(Manager &mgr, std::string name, Handle<Domain> domain)
: Node(mgr, std::move(name), domain),
- attributesDescriptor(acquire(attributesDescriptor)),
+ attributesDescriptor(acquire(new StructType(mgr, "", nullptr))),
fieldDescriptors(this)
{
}
@@ -485,17 +485,6 @@ public:
}
/**
- * Sets the StructType that specifies the attributes of this Descriptor.
- *
- * @param t some StructType.
- */
- void setAttributesDescriptor(Handle<StructType> t)
- {
- invalidate();
- attributesDescriptor = acquire(t);
- }
-
- /**
* Returns a const reference to the NodeVector of all FieldDescriptors of
* this Descriptor.
*
@@ -602,8 +591,7 @@ public:
*/
Rooted<FieldDescriptor> createFieldDescriptor(
FieldDescriptor::FieldType fieldType = FieldDescriptor::FieldType::TREE,
- std::string name = DEFAULT_FIELD_NAME,
- bool optional = false);
+ std::string name = DEFAULT_FIELD_NAME, bool optional = false);
/**
* This tries to construct the shortest possible path of this Descriptor
@@ -748,9 +736,6 @@ public:
* have at least one author. This is set to *
* per default, meaning that any number of
* of instances is valid, including zero.
- * @param attributesDescriptor is a StructType that specifies the attribute
- * keys as well as value domains for this
- * Descriptor.
* @param superclass references a parent StructuredClass. Please
* look for more information on inheritance in
* the class documentation above. The default is
@@ -767,7 +752,6 @@ public:
StructuredClass(Manager &mgr, std::string name,
Handle<Domain> domain = nullptr,
Variant cardinality = AnyCardinality,
- Handle<StructType> attributesDescriptor = nullptr,
Handle<StructuredClass> superclass = nullptr,
bool transparent = false, bool root = false);
@@ -793,10 +777,15 @@ public:
* This will also register this class as a subclass at the given superclass
* and unregister it at the previous superclass.
*
- * @parem sup some StructuredClass that shall be the new superclass of this
- * StructuredClass.
+ * It will also set the parent for this Descriptors AttributesDescriptor.
+ *
+ * @param sup some StructuredClass that shall be the new superclass of
+ * this StructuredClass.
+ * @param logger is some logger. Errors during setting the parent for this
+ * Descriptors AttributesDescriptor will be written into this
+ * logger.
*/
- void setSuperclass(Handle<StructuredClass> sup);
+ void setSuperclass(Handle<StructuredClass> sup, Logger &logger);
/**
* Returns true if this class is a subclass of the given class. It does not
@@ -832,16 +821,22 @@ public:
* on the given subclass.
*
* @param sc is some StructuredClass.
+ * @param logger is some logger. Errors during setting the parent for the
+ * new subclasses AttributesDescriptor will be written into
+ * this logger.
*/
- void addSubclass(Handle<StructuredClass> sc);
+ void addSubclass(Handle<StructuredClass> sc, Logger& logger);
/**
* Removes a subclass from this StructuredClass. This also calls
* setSuperclass(nullptr) on the given subclass.
*
* @param sc is some StructuredClass.
+ * @param logger is some logger. Errors during setting the parent for the
+ * removed subclasses AttributesDescriptor will be written
+ * into this logger.
*/
- void removeSubclass(Handle<StructuredClass> sc);
+ void removeSubclass(Handle<StructuredClass> sc, Logger& logger);
/**
* Returns a const reference to the NodeVector of all FieldDescriptors of
@@ -891,13 +886,8 @@ public:
* AnnotationClass.
* @param domain is the Domain this AnnotationClass belongs
* to.
- * @param attributesDescriptor is a StructType that specifies the attribute
- * keys as well as value domains for this
- * Descriptor.
*/
- AnnotationClass(Manager &mgr, std::string name, Handle<Domain> domain,
- // TODO: What would be a wise default value for attributes?
- Handle<StructType> attributesDescriptor = nullptr);
+ AnnotationClass(Manager &mgr, std::string name, Handle<Domain> domain);
};
/**
@@ -1004,9 +994,6 @@ public:
* have at least one author. This is set to *
* per default, meaning that any number of
* of instances is valid, including zero.
- * @param attributesDescriptor is a StructType that specifies the attribute
- * keys as well as value domains for this
- * Descriptor.
* @param superclass references a parent StructuredClass. Please
* look for more information on inheritance in
* the class documentation above. The default is
@@ -1024,7 +1011,6 @@ public:
*/
Rooted<StructuredClass> createStructuredClass(
std::string name, Variant cardinality = AnyCardinality,
- Handle<StructType> attributesDescriptor = nullptr,
Handle<StructuredClass> superclass = nullptr, bool transparent = false,
bool root = false);
@@ -1064,12 +1050,8 @@ public:
* @param name is a name for this AnnotationClass that will
* be used for later references to this
* AnnotationClass.
- * @param attributesDescriptor is a StructType that specifies the attribute
- * keys as well as value domains for this
- * Descriptor.
*/
- Rooted<AnnotationClass> createAnnotationClass(
- std::string name, Handle<StructType> attributesDescriptor = nullptr);
+ Rooted<AnnotationClass> createAnnotationClass(std::string name);
/**
* Returns a const reference to the NodeVector of TypeSystems that are
diff --git a/src/core/parser/ParserScope.hpp b/src/core/parser/ParserScope.hpp
index 7be3c4a..1de1592 100644
--- a/src/core/parser/ParserScope.hpp
+++ b/src/core/parser/ParserScope.hpp
@@ -197,7 +197,6 @@ public:
{
return selectOrThrow(RttiSet{&typeOf<T>()}, maxDepth).cast<T>();
}
-
};
/**
@@ -638,6 +637,27 @@ public:
}
/**
+ * Tries to resolve a node for the given type and path for all nodes that
+ * are currently in the stack, starting with the topmost node on the stack.
+ *
+ * @tparam T is the type of the node that should be resolved.
+ * @param path is the path for which a node should be resolved.
+ * @param logger is the logger instance into which resolution problems
+ * should be logged.
+ * @return a reference at a resolved node or nullptr if no node could be
+ * found.
+ */
+ template <class T>
+ Rooted<T> resolve(const std::vector<std::string> &path, Logger &logger)
+ {
+ // TODO: Rooted<Node> res = resolve(typeOf<T>(), path,
+ // logger).cast<T>();
+ // does not work. Why? Bother stackoverflow with this.
+ Rooted<Node> res = ParserScopeBase::resolve(typeOf<T>(), path, logger);
+ return res.cast<T>();
+ }
+
+ /**
* Resolves a typesystem type. Makes sure an array type is returned if an
* array type is requested.
*
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-01 03:01:11 +0000