From 235cf24518ca40bec59b497a416d9831db12eaa3 Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Thu, 8 Jan 2015 21:30:31 +0100 Subject: further extended example to include annotations (emphasized and strong). The DemoOutput for that is still missing, though. convenience build functions have also been implemented in Document.cpp. --- src/core/model/Document.cpp | 54 +++++++++++++++++++++++++++++++++++++++-- src/core/model/Document.hpp | 58 ++++++++++++++++++++++++++++++++++++--------- src/core/model/Domain.hpp | 10 ++++++-- 3 files changed, 107 insertions(+), 15 deletions(-) (limited to 'src/core/model') diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp index 073f728..c653fe3 100644 --- a/src/core/model/Document.cpp +++ b/src/core/model/Document.cpp @@ -100,7 +100,7 @@ static Rooted resolveDescriptor( } // Otherwise take the first valid result. for (auto &r : resolved) { - if(r->isa(typeOf())){ + if (r->isa(typeOf())) { return r.cast(); } } @@ -155,6 +155,9 @@ Rooted StructuredEntity::buildEntity( return {nullptr}; } // append the new entity to the right field. + if (!parent->hasField(fieldName)) { + return {nullptr}; + } NodeVector &field = parent->getField(fieldName); field.push_back(entity); @@ -178,13 +181,60 @@ Rooted DocumentPrimitive::buildEntity( return {nullptr}; } // append the new entity to the right field. + if (!parent->hasField(fieldName)) { + return {nullptr}; + } NodeVector &field = parent->getField(fieldName); field.push_back(entity); - // and return it. return entity; } +Rooted AnnotationEntity::buildAnchor( + Handle parent, std::string id, const std::string &fieldName) +{ + // If the parent is not set, we can not build the anchor. + if (parent == nullptr) { + return {nullptr}; + } + // Then construct the Anchor itself + Rooted anchor{ + new AnnotationEntity::Anchor(parent->getManager(), parent, id)}; + // append the new entity to the right field. + if (!parent->hasField(fieldName)) { + return {nullptr}; + } + NodeVector &field = parent->getField(fieldName); + field.push_back(anchor); + // and return it. + return anchor; +} + +Rooted AnnotationEntity::buildEntity( + Handle parent, std::vector> domains, + const std::string &className, Handle start, + Handle end, Variant attributes, std::string name) +{ + // If the parent is not set, we can not build the AnnotationEntity. + if (parent == nullptr) { + return {nullptr}; + } + // If we can not find the correct descriptor, we can not build the entity + // either. + Rooted descriptor = resolveDescriptor(domains, className); + if (descriptor == nullptr) { + return {nullptr}; + } + // Then construct the AnnotationEntity itself + Rooted anno{ + new AnnotationEntity(parent->getManager(), parent, descriptor, + attributes, start, end, name)}; + // append the new entity to the document + parent->getAnnotations().push_back(anno); + // and return it. + return anno; +} + /* Type registrations */ } diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp index 7523962..993df9e 100644 --- a/src/core/model/Document.hpp +++ b/src/core/model/Document.hpp @@ -207,21 +207,15 @@ public: * information please refer to the header documentation above. */ class StructuredEntity : public DocumentEntity { -private: - NodeVector annotations; - public: StructuredEntity(Manager &mgr, Handle parent, Handle descriptor, Variant attributes, std::string name = "") : DocumentEntity(mgr, parent, descriptor, std::move(attributes), - std::move(name)), - annotations(this) + std::move(name)) { } - NodeVector &getAnnotations() { return annotations; } - /** * This builds the root StructuredEntity for the given document. It * automatically appends the newly build entity to the given document. @@ -343,12 +337,11 @@ public: public: /** * @param mgr is the Manager instance. - * @param name is the Anchor id. * @param parent is the parent of this Anchor in the Structure Tree (!), * not the AnnotationEntity that references this Anchor. + * @param name is the Anchor id. */ - Anchor(Manager &mgr, Handle parent, - std::string name = "") + Anchor(Manager &mgr, Handle parent, std::string name) : StructuredEntity(mgr, parent, nullptr, Variant(), std::move(name)) { } @@ -372,6 +365,45 @@ public: Rooted getStart() { return start; } Rooted getEnd() { return end; } + + /** + * This builds an Anchor as child of the given DocumentEntity. It + * automatically appends the newly build Anchor to its parent. + * + * @param parent is the parent DocumentEntity. The newly constructed + * Anchor will automatically be appended to it. + * @param id is the id of this Anchor. + * @param fieldName is the name of the field where the newly constructed + * Anchor shall be appended. + * + * @return the newly created Anchor or a nullptr if some + * input handle was empty. + */ + static Rooted buildAnchor(Handle parent, + std::string id, + const std::string &fieldName = ""); + /** + * This builds an AnnotationEntity as child of the given DocumentEntity. It + * automatically appends the newly build entity to its parent. + * + * @param parent is the document the newly constructed AnnotationEntity + * will be appended to. + * @param domains are the domains that are used to find the + * AnnotationClass for the new node. The domains will be + * searched in the given order. + * @param className is the name of the AnnotationClass. + * @param attributes are the attributes of the new node in terms of a Struct + * variant (empty per default). + * @param name is the name of this AnnotationEntity (empty per + * default). + * @return the newly created AnnotationEntity or a nullptr if some + * input handle was empty or the given domains did not + * contain a AnnotationClass with the given name. + */ + static Rooted buildEntity(Handle parent, std::vector> domains, + const std::string &className, + Handle start, Handle end, + Variant attributes = Variant(), std::string name = ""); }; /** @@ -382,17 +414,21 @@ class Document : public Node { private: // TODO: Might there be several roots? E.g. metadata? Owned root; + NodeVector annotations; public: Document(Manager &mgr, std::string name) // TODO: Can a document have a parent? - : Node(mgr, std::move(name), nullptr) + : Node(mgr, std::move(name), nullptr), + annotations(this) { } void setRoot(Handle root) { this->root = acquire(root); }; Rooted getRoot() const { return root; } + + NodeVector getAnnotations() { return annotations; } }; } diff --git a/src/core/model/Domain.hpp b/src/core/model/Domain.hpp index 6a07b32..027cf88 100644 --- a/src/core/model/Domain.hpp +++ b/src/core/model/Domain.hpp @@ -306,8 +306,7 @@ public: */ FieldDescriptor(Manager &mgr, Handle parent, FieldType fieldType = FieldType::TREE, - std::string name = "", - bool optional = false) + std::string name = "", bool optional = false) : Node(mgr, std::move(name), parent), children(this), fieldType(fieldType), @@ -532,6 +531,13 @@ public: * This class has no special properties and is in essence just a Descriptor. */ class AnnotationClass : public Descriptor { +public: + AnnotationClass(Manager &mgr, std::string name, Handle domain, + // TODO: What would be a wise default value for attributes? + Handle attributesDescriptor) + : Descriptor(mgr, std::move(name), domain, attributesDescriptor) + { + } }; /** -- cgit v1.2.3