From 0fd65daf57959fe5409a624bffcd5998fc55d332 Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Sun, 18 Jan 2015 16:52:54 +0100 Subject: improved Document validation process and added some test cases. Further tests are required, though. --- src/core/model/Document.cpp | 76 ++++++++++++++++++++++++++++++--------------- src/core/model/Document.hpp | 30 +++++++++++++----- 2 files changed, 73 insertions(+), 33 deletions(-) (limited to 'src/core/model') diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp index cf6ded3..b80cb5e 100644 --- a/src/core/model/Document.cpp +++ b/src/core/model/Document.cpp @@ -92,10 +92,27 @@ int DocumentEntity::getFieldDescriptorIndex( } } -DocumentEntity::DocumentEntity(Handle owner, +void DocumentEntity::addStructureNode(Handle s, + const std::string &fieldName) +{ + if (subInst->isa(RttiTypes::StructuredEntity)) { + const StructuredEntity *s = + static_cast(subInst); + s->invalidate(); + } else { + const AnnotationEntity *a = + static_cast(subInst); + a->invalidate(); + } + fields[getFieldDescriptorIndex(fieldName, true)].push_back(s); +} + +DocumentEntity::DocumentEntity(Handle subInst, Handle descriptor, Variant attributes) - : descriptor(owner->acquire(descriptor)), attributes(std::move(attributes)) + : subInst(subInst.get()), + descriptor(subInst->acquire(descriptor)), + attributes(std::move(attributes)) { // insert empty vectors for each field. if (!descriptor.isNull()) { @@ -107,7 +124,7 @@ DocumentEntity::DocumentEntity(Handle owner, fieldDescs = descriptor->getFieldDescriptors(); } for (size_t f = 0; f < fieldDescs.size(); f++) { - fields.push_back(NodeVector(owner)); + fields.push_back(NodeVector(subInst)); } } } @@ -120,6 +137,7 @@ bool DocumentEntity::doValidate(Logger &logger) const return false; } // TODO: check the validated form of Attributes + // TODO: Check if descriptor is registered at the Document? /* * generate the set of effective fields. This is trivial for @@ -150,8 +168,7 @@ bool DocumentEntity::doValidate(Logger &logger) const const size_t min = ac->getCardinality().min(); if (min > 0) { logger.error( - std::string("Field ") + - descriptor->getFieldDescriptors()[f]->getName() + + std::string("Field ") + fieldDescs[f]->getName() + " was empty but needs at least " + std::to_string(min) + " elements of class " + ac->getName() + " according to the definition of " + @@ -172,11 +189,11 @@ bool DocumentEntity::doValidate(Logger &logger) const // iterate over every actual child of this DocumentEntity for (auto &rc : fields[f]) { - if (!rc->isa(RttiTypes::Anchor)) { + if (rc->isa(RttiTypes::Anchor)) { // Anchors are uninteresting and can be ignored. continue; } - if (!rc->isa(RttiTypes::DocumentPrimitive)) { + if (rc->isa(RttiTypes::DocumentPrimitive)) { // For DocumentPrimitives we have to check the content type. // TODO: Do that! continue; @@ -281,6 +298,12 @@ bool StructuredEntity::doValidate(Logger &logger) const if (getParent() == nullptr) { return false; } + // check name + if (getName() != "") { + if (!validateName(logger)) { + return false; + } + } // check the validity as a DocumentEntity. return DocumentEntity::doValidate(logger); } @@ -317,6 +340,12 @@ bool AnnotationEntity::doValidate(Logger &logger) const logger.error("This annotation was not registered at the document."); return false; } + // check name + if (getName() != "") { + if (!validateName(logger)) { + return false; + } + } // check if the Anchors are part of the right document. if (!doc->hasChild(start)) { return false; @@ -344,26 +373,23 @@ void Document::doResolve(ResolutionState &state) bool Document::doValidate(Logger &logger) const { - if (root != nullptr) { - // check if the root is allowed to be a root. - if (!root->getDescriptor().cast()->root) { - logger.error(std::string("A node of type ") + - root->getDescriptor()->getName() + - " is not allowed to be the Document root!"); - return false; - } - // then call validate on the root - if (!root->validate(logger)) { - return false; - } + // An empty document is always invalid. TODO: Is this a smart choice? + if (root == nullptr) { + return false; } - // call validate on the AnnotationEntities - for (auto &a : annotations) { - if (!a->validate(logger)) { - return false; - } + // check if the root is allowed to be a root. + if (!root->getDescriptor().cast()->root) { + logger.error(std::string("A node of type ") + + root->getDescriptor()->getName() + + " is not allowed to be the Document root!"); + return false; } - return true; + // then call validate on the root + if (!root->validate(logger)) { + return false; + } + // call validate on the AnnotationEntities + return continueValidation(annotations, logger); } bool Document::hasChild(Handle s) const diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp index b4ee429..15d002c 100644 --- a/src/core/model/Document.hpp +++ b/src/core/model/Document.hpp @@ -144,6 +144,12 @@ class DocumentEntity { friend StructureNode; private: + /* + * this is a rather dirty method that should not be used in other cases: + * We store a pointer to the Node instance that inherits from + * DocumentEntity. + */ + const Node *subInst; Owned descriptor; const Variant attributes; std::vector> fields; @@ -156,10 +162,7 @@ private: protected: void addStructureNode(Handle s, - const std::string &fieldName = "") - { - fields[getFieldDescriptorIndex(fieldName, true)].push_back(s); - } + const std::string &fieldName = ""); bool doValidate(Logger &logger) const; @@ -169,7 +172,7 @@ public: * from Node. Therefore we need to have a handle to the subclass Node * instance to create NodeVectors and Owned references. * - * @param owner is a handle to the subclass instance + * @param subInst is a handle to the subclass instance * (e.g. StructuredEntity), such that the fields vectors * and the descriptor reference can be obtained. * @param descriptor is the Descriptor for this DocumentEntity, which will @@ -177,7 +180,7 @@ public: * @param attributes is a Map Variant adhering to the attribute StructType * in the given descriptor. */ - DocumentEntity(Handle owner, Handle descriptor, + DocumentEntity(Handle subInst, Handle descriptor, Variant attributes = {}); /** @@ -498,6 +501,8 @@ public: * */ class AnnotationEntity : public Node, public DocumentEntity { + friend DocumentEntity; + private: Owned start; Owned end; @@ -573,7 +578,11 @@ public: /** * Sets the root StructuredEntity of this Document. */ - void setRoot(Handle root) { this->root = acquire(root); }; + void setRoot(Handle root) + { + invalidate(); + this->root = acquire(root); + }; /** * Returns the root StructuredEntity of this Document. @@ -606,13 +615,18 @@ public: /** * Adds a Domain reference to this Document. */ - void addDomain(Handle d) { domains.push_back(d); } + void addDomain(Handle d) + { + invalidate(); + domains.push_back(d); + } /** * Adds multiple Domain references to this Document. */ void addDomains(const std::vector> &d) { + invalidate(); domains.insert(domains.end(), d.begin(), d.end()); } -- cgit v1.2.3