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/Domain.hpp | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'src/core/model/Domain.hpp') 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(-) (limited to 'src/core/model/Domain.hpp') 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