From a1245cf2ad80cba0a71ffb184966ee77a7e166cc Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Thu, 15 Jan 2015 14:18:07 +0100 Subject: Further simplified document buildup by doing the addition to parents of StructureNodes in the constructor and refactored Anchor as standalone class instead of AnnotationEntity child. This made some changes in the test bench necessary as well. --- src/core/model/Document.cpp | 41 +++++- src/core/model/Document.hpp | 287 ++++++++++++++++++++++++++-------------- src/plugins/html/DemoOutput.cpp | 3 +- 3 files changed, 219 insertions(+), 112 deletions(-) (limited to 'src') diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp index eca24e7..299b427 100644 --- a/src/core/model/Document.cpp +++ b/src/core/model/Document.cpp @@ -89,11 +89,38 @@ int DocumentEntity::getFieldDescriptorIndex( } } +/* Class StructureNode */ + +StructureNode::StructureNode(Manager &mgr, std::string name, + Handle parent, const std::string &fieldName) + : Node(mgr, std::move(name), parent) +{ + if(parent->isa(RttiTypes::StructuredEntity)){ + parent.cast()->addStructureNode(this, fieldName); + } else if(parent->isa(RttiTypes::AnnotationEntity)){ + parent.cast()->addStructureNode(this, fieldName); + } else{ + throw OusiaException("The proposed parent was no DocumentEntity!"); + } +} + +/* Class StructuredEntity */ + +StructuredEntity::StructuredEntity(Manager &mgr, Handle doc, + Handle descriptor, + Variant attributes, std::string name) + : StructureNode(mgr, std::move(name), doc), + DocumentEntity(this, descriptor, std::move(attributes)) +{ + doc->setRoot(this); +} + /* Class AnnotationEntity */ AnnotationEntity::AnnotationEntity(Manager &mgr, Handle parent, - Handle descriptor, Handle start, - Handle end, Variant attributes, std::string name) + Handle descriptor, + Handle start, Handle end, + Variant attributes, std::string name) : Node(mgr, std::move(name), parent), DocumentEntity(this, descriptor, attributes), start(acquire(start)), @@ -121,15 +148,15 @@ const Rtti Document = {&AnnotationEntity, &StructuredEntity}); const Rtti StructureNode = RttiBuilder("StructureNode").parent(&Node); -const Rtti AnnotationEntity = - RttiBuilder("AnnotationEntity").parent(&Node).composedOf(&StructureNode); const Rtti StructuredEntity = RttiBuilder("StructuredEntity").parent(&StructureNode).composedOf( - {&StructureNode}); + {&StructuredEntity, &DocumentPrimitive, &Anchor}); const Rtti DocumentPrimitive = RttiBuilder("DocumentPrimitive").parent(&StructureNode); -const Rtti Anchor = - RttiBuilder("Anchor").parent(&StructureNode); +const Rtti Anchor = RttiBuilder("Anchor").parent(&StructureNode); +const Rtti AnnotationEntity = + RttiBuilder("AnnotationEntity").parent(&Node).composedOf( + {&StructuredEntity, &DocumentPrimitive, &Anchor}); } } diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp index 9a8719c..be8b5c8 100644 --- a/src/core/model/Document.hpp +++ b/src/core/model/Document.hpp @@ -139,6 +139,8 @@ class StructureNode; * */ class DocumentEntity { + friend StructureNode; + private: Owned descriptor; const Variant attributes; @@ -150,6 +152,13 @@ private: int getFieldDescriptorIndex(Handle fieldDescriptor, bool enforce) const; +protected: + void addStructureNode(Handle s, + const std::string &fieldName = "") + { + fields[getFieldDescriptorIndex(fieldName, true)].push_back(s); + } + public: /** * The constructor for a DocumentEntity. Node that this does not inherit @@ -169,7 +178,6 @@ public: : descriptor(owner->acquire(descriptor)), attributes(std::move(attributes)) { - // TODO: Validation at construction time? // insert empty vectors for each field. if (!descriptor.isNull()) { for (size_t f = 0; f < descriptor->getFieldDescriptors().size(); @@ -247,79 +255,85 @@ public: { return fields[getFieldDescriptorIndex(fieldDescriptor, true)]; } - /** - * This adds a StructureNode to the field with the given name. If an - * empty name is given it is assumed that the 'default' FieldDescriptor is - * referenced, where 'default' means either: - * 1.) The only TREE typed FieldDescriptor (if present) or - * 2.) the only FieldDescriptor (if only one is specified). - * - * If the name is unknown an exception is thrown. - * - * @param s is the StructureNode that shall be added. - * @param fieldName is the name of a field as specified in the - * FieldDescriptor in the Domain description. - */ - void addStructureNode(Handle s, - const std::string &fieldName = "") - { - fields[getFieldDescriptorIndex(fieldName, true)].push_back(s); - } - /** - * This adds multiple StructureNodes to the field with the given name. - * If an empty name is given it is assumed that the 'default' - * FieldDescriptor is referenced, where 'default' means either: - * 1.) The only TREE typed FieldDescriptor (if present) or - * 2.) the only FieldDescriptor (if only one is specified). - * - * If the name is unknown an exception is thrown. - * - * @param ss are the StructureNodes that shall be added. - * @param fieldName is the name of a field as specified in the - * FieldDescriptor in the Domain description. - */ - void addStructureNodes(const std::vector> &ss, - const std::string &fieldName = "") - { - NodeVector &field = - fields[getFieldDescriptorIndex(fieldName, true)]; - field.insert(field.end(), ss.begin(), ss.end()); - } - - /** - * This adds a StructureNode to the field with the given FieldDescriptor. - * - * If the FieldDescriptor does not belong to the Descriptor of this node - * an exception is thrown. - * - * @param s is the StructureNode that shall be added. - * @param fieldDescriptor is a FieldDescriptor defined in the Descriptor for - * this DocumentEntity. - */ - void addStructureNode(Handle s, - Handle fieldDescriptor) - { - fields[getFieldDescriptorIndex(fieldDescriptor, true)].push_back(s); - } - /** - * This adds multiple StructureNodes to the field with the given - * FieldDescriptor. - * - * If the FieldDescriptor does not belong to the Descriptor of this node - * an exception is thrown. - * - * @param ss are the StructureNodes that shall be added. - * @param fieldDescriptor is a FieldDescriptor defined in the Descriptor for - * this DocumentEntity. - */ - void addStructureNodes(const std::vector> &ss, - Handle fieldDescriptor) - { - NodeVector &field = - fields[getFieldDescriptorIndex(fieldDescriptor, true)]; - field.insert(field.end(), ss.begin(), ss.end()); - } + // TODO: Change this to move methods. + // /** + // * This adds a StructureNode to the field with the given name. If an + // * empty name is given it is assumed that the 'default' FieldDescriptor + // is + // * referenced, where 'default' means either: + // * 1.) The only TREE typed FieldDescriptor (if present) or + // * 2.) the only FieldDescriptor (if only one is specified). + // * + // * If the name is unknown an exception is thrown. + // * + // * @param s is the StructureNode that shall be added. + // * @param fieldName is the name of a field as specified in the + // * FieldDescriptor in the Domain description. + // */ + // void addStructureNode(Handle s, + // const std::string &fieldName = "") + // { + // fields[getFieldDescriptorIndex(fieldName, true)].push_back(s); + // } + // /** + // * This adds multiple StructureNodes to the field with the given name. + // * If an empty name is given it is assumed that the 'default' + // * FieldDescriptor is referenced, where 'default' means either: + // * 1.) The only TREE typed FieldDescriptor (if present) or + // * 2.) the only FieldDescriptor (if only one is specified). + // * + // * If the name is unknown an exception is thrown. + // * + // * @param ss are the StructureNodes that shall be added. + // * @param fieldName is the name of a field as specified in the + // * FieldDescriptor in the Domain description. + // */ + // void addStructureNodes(const std::vector> &ss, + // const std::string &fieldName = "") + // { + // NodeVector &field = + // fields[getFieldDescriptorIndex(fieldName, true)]; + // field.insert(field.end(), ss.begin(), ss.end()); + // } + + // /** + // * This adds a StructureNode to the field with the given + // FieldDescriptor. + // * + // * If the FieldDescriptor does not belong to the Descriptor of this node + // * an exception is thrown. + // * + // * @param s is the StructureNode that shall be added. + // * @param fieldDescriptor is a FieldDescriptor defined in the Descriptor + // for + // * this DocumentEntity. + // */ + // void addStructureNode(Handle s, + // Handle fieldDescriptor) + // { + // fields[getFieldDescriptorIndex(fieldDescriptor, true)].push_back(s); + // } + + // /** + // * This adds multiple StructureNodes to the field with the given + // * FieldDescriptor. + // * + // * If the FieldDescriptor does not belong to the Descriptor of this node + // * an exception is thrown. + // * + // * @param ss are the StructureNodes that shall be added. + // * @param fieldDescriptor is a FieldDescriptor defined in the Descriptor + // for + // * this DocumentEntity. + // */ + // void addStructureNodes(const std::vector> &ss, + // Handle fieldDescriptor) + // { + // NodeVector &field = + // fields[getFieldDescriptorIndex(fieldDescriptor, true)]; + // field.insert(field.end(), ss.begin(), ss.end()); + // } }; /** @@ -328,10 +342,19 @@ public: */ class StructureNode : public Node { public: - StructureNode(Manager &mgr, std::string name, Handle parent) - : Node(mgr, std::move(name), parent) + /** + * Constructor for a StructureNode at the root. + */ + StructureNode(Manager &mgr, std::string name, Handle doc) + : Node(mgr, std::move(name), doc) { } + + /** + * Constructor for a StructureNode in the StructureTree. + */ + StructureNode(Manager &mgr, std::string name, Handle parent, + const std::string &fieldName); }; /** @@ -340,13 +363,48 @@ public: */ class StructuredEntity : public StructureNode, public DocumentEntity { public: + /** + * Constructor for a StructuredEntity in the Structure Tree. + * + * @param mgr is the Manager instance. + * @param parent is the parent DocumentEntity of this StructuredEntity + * in the DocumentTree. Note that this StructuredEntity + * will automatically register itself as child of this + * parent. + * @param descriptor is the StructuredClass of this StructuredEntity. + * @param attributes is a Map Variant containing attribute fillings for this + * StructuredEntity. It is empty per default. + * @param fieldName is the name of the field in the parent DocumentEntity + * where this StructuredEntity shall be added. It is empty + * per default, referring to the default field. + * @param name is some name for this StructuredEntity that may be used + * for later reference. It is empty per default. + */ StructuredEntity(Manager &mgr, Handle parent, - Handle descriptor, Variant attributes, + Handle descriptor, + Variant attributes = {}, const std::string &fieldName = "", std::string name = "") - : StructureNode(mgr, std::move(name), parent), + : StructureNode(mgr, std::move(name), parent, fieldName), DocumentEntity(this, descriptor, std::move(attributes)) { } + + /** + * Constructor for a StructuredEntity at the document root. + * + * @param mgr is the Manager instance. + * @param parent is the parent Document of this StructuredEntity. Note + * that this StructuredEntity will automatically register + * itself as child of this Document. + * @param descriptor is the StructuredClass of this StructuredEntity. + * @param attributes is a Map Variant containing attribute fillings for this + * StructuredEntity. It is empty per default. + * @param name is some name for this StructuredEntity that may be used + * for later reference. It is empty per default. + */ + StructuredEntity(Manager &mgr, Handle doc, + Handle descriptor, + Variant attributes = {}, std::string name = ""); }; /** @@ -359,8 +417,25 @@ private: Variant content; public: - DocumentPrimitive(Manager &mgr, Handle parent, Variant content = {}) - : StructureNode(mgr, "", parent), content(content) + /** + * Constructor for a DocumentPrimitive. + * + * @param mgr is the Manager instance. + * @param parent is the parent DocumentEntity of this DocumentPrimitive + * in the DocumentTree. Note that this DocumentPrimitive + * will automatically register itself as child of this + * parent. + * @param content is a Variant containing the content of this + * DocumentPrimitive. The Type of this Variant is + * specified at the parents Descriptor for the given + * fieldName. + * @param fieldName is the name of the field in the parent DocumentEntity + * where this DocumentPrimitive shall be added. It is empty + * per default, referring to the default field. + */ + DocumentPrimitive(Manager &mgr, Handle parent, Variant content, + const std::string &fieldName = "") + : StructureNode(mgr, "", parent, fieldName), content(content) { } @@ -372,6 +447,34 @@ public: Variant getContent() const { return content; } }; +/** + * An Anchor is an elementary StructureNode without any children that + * marks a point in the text content of the document that can later be + * referenced by an AnnotationEntity as it start and end point. + * Please refer to the AnnotationEntity documentation for more information. + */ +class Anchor : public StructureNode { +public: + /** + * Constructor for Anchor. + * + * @param mgr is the Manager instance. + * @param parent is the parent of this Anchor in the Structure Tree (!), + * not the AnnotationEntity that references this Anchor. + * Note that this Anchor will automatically register itself + * as child of the given parent. + * @param name is the Anchor id. + * @param fieldName is the name of the field in the parent DocumentEntity + * where this Anchor shall be added. It is empty + * per default, referring to the default field. + */ + Anchor(Manager &mgr, std::string name, Handle parent, + const std::string &fieldName = "") + : StructureNode(mgr, std::move(name), parent, fieldName) + { + } +}; + /** * An AnnotationEntity is a span-like instance that is not bound by the elements * of the Structure Tree. An annotation may very well overlap and cross the @@ -397,27 +500,6 @@ public: * */ class AnnotationEntity : public Node, public DocumentEntity { -public: - /** - * An Anchor is an elementary StructuredEntity without any children that - * marks a point in the text content of the document that can later be - * referenced by an AnnotationEntity as it start and end point. - * Please refer to the AnnotationEntity documentation for more information. - */ - class Anchor : public StructureNode { - public: - /** - * @param mgr is the Manager instance. - * @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, std::string name, Handle parent) - : StructureNode(mgr, std::move(name), parent) - { - } - }; - private: Owned start; Owned end; @@ -466,8 +548,7 @@ public: * document and the AnnotationEntities that span over Anchors in this Document. */ class Document : public Node { - -friend AnnotationEntity; + friend AnnotationEntity; private: // TODO: Might there be several roots? E.g. metadata? @@ -540,7 +621,7 @@ extern const Rtti AnnotationEntity; extern const Rtti StructureNode; extern const Rtti StructuredEntity; extern const Rtti DocumentPrimitive; -extern const Rtti Anchor; +extern const Rtti Anchor; } } diff --git a/src/plugins/html/DemoOutput.cpp b/src/plugins/html/DemoOutput.cpp index b94b397..a3d1b84 100644 --- a/src/plugins/html/DemoOutput.cpp +++ b/src/plugins/html/DemoOutput.cpp @@ -203,7 +203,6 @@ Rooted DemoHTMLTransformer::transformList( return l; } -typedef model::AnnotationEntity::Anchor Anchor; typedef std::stack> AnnoStack; static Rooted openAnnotation( @@ -262,7 +261,7 @@ Rooted DemoHTMLTransformer::transformParagraph( // this is a handle for our current XML element for annotation handling. Rooted current = p; for (auto &n : par->getField()) { - if (n->isa(typeOf())) { + if (n->isa(RttiTypes::Anchor)) { // check if this is a start Anchor. // here we assume, again, that the ids/names of anchors are unique. auto it = startMap.find(n->getName()); -- cgit v1.2.3