From f93c95dbd4aab6ebbccc647da5d1d2da437417ce Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Sat, 20 Dec 2014 14:48:03 +0100 Subject: replaces ManagedVector by NodeVector in Model classes. --- src/core/model/Document.cpp | 16 ++++++++-------- src/core/model/Document.hpp | 22 +++++++++++----------- src/core/model/Domain.hpp | 44 ++++++++++++++++++++++---------------------- 3 files changed, 41 insertions(+), 41 deletions(-) diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp index 709981b..497bb43 100644 --- a/src/core/model/Document.cpp +++ b/src/core/model/Document.cpp @@ -25,7 +25,7 @@ namespace model { int DocumentEntity::getFieldDescriptorIndex(const std::string &fieldName) { - const ManagedVector &fds = + const NodeVector &fds = descriptor->getFieldDescriptors(); unsigned int f = 0; @@ -57,21 +57,21 @@ int DocumentEntity::getFieldDescriptorIndex(const std::string &fieldName) return -1; } -void DocumentEntity::getField(ManagedVector &res, +void DocumentEntity::getField(NodeVector &res, const std::string &fieldName) { int f = getFieldDescriptorIndex(fieldName); if (f < 0) { - ManagedVector empty{this}; - res = ManagedVector(this); + NodeVector empty{this}; + res = NodeVector(this); } res = fields[f]; } -ManagedVector &DocumentEntity::getField( +NodeVector &DocumentEntity::getField( Rooted fieldDescriptor) { - const ManagedVector &fds = + const NodeVector &fds = descriptor->getFieldDescriptors(); int f = 0; for (auto &fd : fds) { @@ -156,7 +156,7 @@ Rooted StructuredEntity::buildEntity( return {nullptr}; } // append the new entity to the right field. - ManagedVector field{parent}; + NodeVector field{parent}; parent->getField(field, fieldName); field.push_back(entity); @@ -180,7 +180,7 @@ Rooted DocumentPrimitive::buildEntity( return {nullptr}; } // append the new entity to the right field. - ManagedVector field{parent}; + NodeVector field{parent}; parent->getField(field, fieldName); field.push_back(entity); diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp index 15a4599..a660da7 100644 --- a/src/core/model/Document.hpp +++ b/src/core/model/Document.hpp @@ -97,7 +97,7 @@ class DocumentEntity : public Node { private: Owned descriptor; const Variant attributes; - std::vector> fields; + std::vector> fields; int getFieldDescriptorIndex(const std::string &fieldName); @@ -114,7 +114,7 @@ public: if (!descriptor.isNull()) { for (size_t f = 0; f < descriptor->getFieldDescriptors().size(); f++) { - fields.push_back(ManagedVector(this)); + fields.push_back(NodeVector(this)); } } } @@ -127,7 +127,7 @@ public: * This allows a direct manipulation of the internal data structure of a * DocumentEntity and is not recommended. TODO: Delete this? */ - std::vector> &getFields() { return fields; } + std::vector> &getFields() { return fields; } /** * This returns true if there is a FieldDescriptor in the Descriptor for @@ -155,7 +155,7 @@ public: * 2.) the only FieldDescriptor (if only one is specified). * * Note that the output of this method might well be ambigous: If no - * FieldDescriptor matches the given name an empty ManagedVector is + * FieldDescriptor matches the given name an empty NodeVector is * returned. This is also the case, however, if there are no members for an * existing field. Therefore it is recommended to additionally check the * output of "hasField" or use the version of this method with @@ -163,13 +163,13 @@ public: * * @param fieldName is the name of the field as specified in the * FieldDescriptor in the Domain description. - * @param res is a ManagedVector reference where the result will be + * @param res is a NodeVector reference where the result will be * stored. After using this method the reference will * either refer to all StructuredEntities in that field. If * the field is unknown or if no members exist in that - * field yet, the ManagedVector will be empty. + * field yet, the NodeVector will be empty. */ - void getField(ManagedVector &res, + void getField(NodeVector &res, const std::string &fieldName = ""); /** @@ -181,9 +181,9 @@ public: * * @param fieldDescriptor is a FieldDescriptor defined in the Descriptor for * this DocumentEntity. - * @return a ManagedVector of all StructuredEntities in that field. + * @return a NodeVector of all StructuredEntities in that field. */ - ManagedVector &getField( + NodeVector &getField( Rooted fieldDescriptor); }; @@ -193,7 +193,7 @@ public: */ class StructuredEntity : public DocumentEntity { private: - ManagedVector annotations; + NodeVector annotations; public: StructuredEntity(Manager &mgr, Handle parent, @@ -205,7 +205,7 @@ public: { } - ManagedVector &getAnnotations() { return annotations; } + NodeVector &getAnnotations() { return annotations; } /** * This builds the root StructuredEntity for the given document. It diff --git a/src/core/model/Domain.hpp b/src/core/model/Domain.hpp index 112f2fa..d0227bd 100644 --- a/src/core/model/Domain.hpp +++ b/src/core/model/Domain.hpp @@ -135,7 +135,7 @@ public: enum class FieldType { TREE, SUBTREE, PRIMITIVE }; private: - ManagedVector children; + NodeVector children; FieldType fieldType; Owned primitiveType; @@ -200,10 +200,10 @@ public: { } - // TODO: Is returning a ManagedVector alright? - ManagedVector &getChildren() { return children; } + // TODO: Is returning a NodeVector alright? + NodeVector &getChildren() { return children; } - const ManagedVector &getChildren() const + const NodeVector &getChildren() const { return children; } @@ -245,7 +245,7 @@ public: class Descriptor : public Node { private: Owned attributesDescriptor; - ManagedVector fieldDescriptors; + NodeVector fieldDescriptors; protected: void doResolve(std::vector> &res, @@ -268,13 +268,13 @@ public: return attributesDescriptor; } - // TODO: Is returning a ManagedVector alright? - ManagedVector &getFieldDescriptors() + // TODO: Is returning a NodeVector alright? + NodeVector &getFieldDescriptors() { return fieldDescriptors; } - const ManagedVector &getFieldDescriptors() const + const NodeVector &getFieldDescriptors() const { return fieldDescriptors; } @@ -361,7 +361,7 @@ class StructuredClass : public Descriptor { private: const Cardinality cardinality; Owned isa; - ManagedVector parents; + NodeVector parents; protected: void doResolve(std::vector> &res, @@ -390,10 +390,10 @@ public: Rooted getIsA() const { return isa; } - // TODO: Is returning a ManagedVector alright? - ManagedVector &getParents() { return parents; } + // TODO: Is returning a NodeVector alright? + NodeVector &getParents() { return parents; } - const ManagedVector &getParents() const { return parents; } + const NodeVector &getParents() const { return parents; } }; /** @@ -413,9 +413,9 @@ class AnnotationClass : public Descriptor { */ class Domain : public Node { private: - ManagedVector rootStructures; - ManagedVector annotationClasses; - ManagedVector typesystems; + NodeVector rootStructures; + NodeVector annotationClasses; + NodeVector typesystems; protected: void doResolve(std::vector> &res, @@ -433,30 +433,30 @@ public: { } - // TODO: Is returning a ManagedVector alright? - ManagedVector &getRootStructures() + // TODO: Is returning a NodeVector alright? + NodeVector &getRootStructures() { return rootStructures; } - const ManagedVector &getRootStructures() const + const NodeVector &getRootStructures() const { return rootStructures; } - ManagedVector &getAnnotationClasses() + NodeVector &getAnnotationClasses() { return annotationClasses; } - const ManagedVector &getAnnotationClasses() const + const NodeVector &getAnnotationClasses() const { return annotationClasses; } - ManagedVector &getTypesystems() { return typesystems; } + NodeVector &getTypesystems() { return typesystems; } - const ManagedVector &getTypesystems() const + const NodeVector &getTypesystems() const { return typesystems; } -- cgit v1.2.3 From f77ec7ae614810bc317c23138279e115f930aa06 Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Sat, 20 Dec 2014 15:14:28 +0100 Subject: Introduced global type variables for model classes and used them in the Domain resolve test, which makes it much easier to understand. --- src/core/model/Document.hpp | 38 +++++++++++++++++++++++++++++++++++-- src/core/model/Domain.hpp | 43 ++++++++++++++++++++++++++++++------------ test/core/model/DomainTest.cpp | 24 +++++++++++------------ 3 files changed, 78 insertions(+), 27 deletions(-) diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp index a660da7..0e0a416 100644 --- a/src/core/model/Document.hpp +++ b/src/core/model/Document.hpp @@ -187,6 +187,11 @@ public: Rooted fieldDescriptor); }; +/** + * A global variable for the ManagedType of a DocumentEntity. + */ +static ManagedType DocumentEntityType{"DocumentEntity", typeid(DocumentEntity)}; + /** * A StructuredEntity is a node in the Structure Tree of a document. For more * information please refer to the header documentation above. @@ -259,6 +264,12 @@ public: Variant attributes = Variant(), std::string name = ""); }; +/** + * A global variable for the ManagedType of a StructuredEntity. + */ +static ManagedType StructuredEntityType{ + "StructuredEntity", typeid(StructuredEntity), {&DocumentEntityType}}; + /** * This is a wrapper for primitive types (Variants) inside the document graph. * The most straightforward example for this is the actual document text, e.g. @@ -292,10 +303,16 @@ public: * contain a StructuredClass with the given name. */ static Rooted buildEntity( - Handle parent, - Variant content, const std::string &fieldName = ""); + Handle parent, Variant content, + const std::string &fieldName = ""); }; +/** + * A global variable for the ManagedType of a DocumentPrimitive. + */ +static ManagedType DocumentPrimitiveType{ + "DocumentPrimitive", typeid(DocumentPrimitive), {&StructuredEntityType}}; + /** * 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 @@ -359,6 +376,18 @@ public: Rooted getEnd() { return end; } }; +/** + * A global variable for the ManagedType of an Anchor. + */ +static ManagedType AnchorType{ + "Anchor", typeid(AnnotationEntity::Anchor), {&StructuredEntityType}}; + +/** + * A global variable for the ManagedType of an AnnotationEntity. + */ +static ManagedType AnnotationEntityType{ + "AnnotationEntity", typeid(AnnotationEntity), {&DocumentEntityType}}; + /** * A Document is mainly a wrapper for the Root structure node of the Document * Graph. @@ -378,6 +407,11 @@ public: Rooted getRoot() const { return root; } }; + +/** + * A global variable for the ManagedType of a Document. + */ +static ManagedType DocumentType{"Document", typeid(Document)}; } } diff --git a/src/core/model/Domain.hpp b/src/core/model/Domain.hpp index d0227bd..d19558e 100644 --- a/src/core/model/Domain.hpp +++ b/src/core/model/Domain.hpp @@ -203,10 +203,7 @@ public: // TODO: Is returning a NodeVector alright? NodeVector &getChildren() { return children; } - const NodeVector &getChildren() const - { - return children; - } + const NodeVector &getChildren() const { return children; } FieldType getFieldType() const { return fieldType; } @@ -215,6 +212,12 @@ public: Rooted getPrimitiveType() const { return primitiveType; } }; +/** + * A global variable for the ManagedType of a FieldDescriptor. + */ +static ManagedType FieldDescriptorType{"FieldDescriptor", + typeid(FieldDescriptor)}; + /** * This is a super class for StructuredClasses and AnnotationClasses and is, * in itself, not supposed to be instantiated. It defines that both, Annotations @@ -280,6 +283,11 @@ public: } }; +/** + * A global variable for the ManagedType of a Descriptor. + */ +static ManagedType DescriptorType{"Descriptor", typeid(Descriptor)}; + typedef RangeSet Cardinality; /** @@ -396,6 +404,12 @@ public: const NodeVector &getParents() const { return parents; } }; +/** + * A global variable for the ManagedType of a StructuredClass. + */ +static ManagedType StructuredClassType{ + "StructuredClass", typeid(StructuredClass), {&DescriptorType}}; + /** * An AnnotationClass defines allowed Annotations. For more information on * Annotations please refer to the Document.hpp. @@ -405,6 +419,12 @@ public: class AnnotationClass : public Descriptor { }; +/** + * A global variable for the ManagedType of an AnnotationClass. + */ +static ManagedType AnnotationClassType{ + "AnnotationClass", typeid(AnnotationClass), {&DescriptorType}}; + /** * A Domain node specifies which StructuredClasses are allowed at the root * level (or which Nonterminals are axioms of the grammar) and which Annotations @@ -434,10 +454,7 @@ public: } // TODO: Is returning a NodeVector alright? - NodeVector &getRootStructures() - { - return rootStructures; - } + NodeVector &getRootStructures() { return rootStructures; } const NodeVector &getRootStructures() const { @@ -456,11 +473,13 @@ public: NodeVector &getTypesystems() { return typesystems; } - const NodeVector &getTypesystems() const - { - return typesystems; - } + const NodeVector &getTypesystems() const { return typesystems; } }; + +/** + * A global variable for the ManagedType of a Domain. + */ +static ManagedType DomainType{"Domain", typeid(Domain)}; } } diff --git a/test/core/model/DomainTest.cpp b/test/core/model/DomainTest.cpp index f6dff3c..204a862 100644 --- a/test/core/model/DomainTest.cpp +++ b/test/core/model/DomainTest.cpp @@ -28,23 +28,21 @@ namespace ousia { namespace model { void assert_path(std::vector> &result, size_t idx, - const std::type_info &expected_type, + const ManagedType &expected_type, std::vector expected_path) { ASSERT_TRUE(result.size() > idx); // check class/type - ASSERT_EQ(expected_type, typeid(*result[idx])); - // transform to node - Managed *m = &(*result[idx]); - Node *n = dynamic_cast(m); - ASSERT_TRUE(n); + ASSERT_TRUE(result[idx]->isa(expected_type)); + // cast to node + Rooted n = result[idx].cast(); // extract actual path std::vector actual_path = n->path(); // check path ASSERT_EQ(expected_path, actual_path); } -TEST(Document, testDomainResolving) +TEST(Domain, testDomainResolving) { // Construct Manager Manager mgr{1}; @@ -59,9 +57,9 @@ TEST(Document, testDomainResolving) std::vector> res = domain->resolve(std::vector{"book"}); // First we expect the book domain. - assert_path(res, 0, typeid(Domain), {"book"}); + assert_path(res, 0, DomainType, {"book"}); // Then the book structure. - assert_path(res, 1, typeid(StructuredClass), {"book", "book"}); + assert_path(res, 1, StructuredClassType, {"book", "book"}); ASSERT_EQ(2, res.size()); /* @@ -69,7 +67,7 @@ TEST(Document, testDomainResolving) * StructuredClass should be returned. */ res = domain->resolve(std::vector{"book", "book"}); - assert_path(res, 0, typeid(StructuredClass), {"book", "book"}); + assert_path(res, 0, StructuredClassType, {"book", "book"}); ASSERT_EQ(1, res.size()); /* @@ -77,7 +75,7 @@ TEST(Document, testDomainResolving) */ res = domain->resolve(std::vector{"section"}); // TODO: Is that the path result we want? - assert_path(res, 0, typeid(StructuredClass), {"book", "section"}); + assert_path(res, 0, StructuredClassType, {"book", "section"}); ASSERT_EQ(1, res.size()); /* @@ -85,7 +83,7 @@ TEST(Document, testDomainResolving) * FieldDescriptor of the StructuredClass "book". */ res = domain->resolve(std::vector{"book", "book", ""}); - assert_path(res, 0, typeid(FieldDescriptor), {"book", "book", ""}); + assert_path(res, 0, FieldDescriptorType, {"book", "book", ""}); ASSERT_EQ(1, res.size()); /* @@ -93,7 +91,7 @@ TEST(Document, testDomainResolving) * but should be returned only once. */ res = domain->resolve("paragraph"); - assert_path(res, 0, typeid(StructuredClass), {"book", "paragraph"}); + assert_path(res, 0, StructuredClassType, {"book", "paragraph"}); ASSERT_EQ(1, res.size()); } } -- cgit v1.2.3