From 3883e6df939ad1ecb9a788153e087fefd9f0e838 Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Fri, 6 Feb 2015 16:47:49 +0100 Subject: corrected attributes descriptor handling. --- src/core/model/Domain.cpp | 67 +++++++++++++++++++------------------ src/core/model/Domain.hpp | 68 ++++++++++++++------------------------ test/core/model/DocumentTest.cpp | 24 ++++++-------- test/core/model/DomainTest.cpp | 32 +++++++++--------- test/core/model/TestAdvanced.hpp | 6 ++-- test/core/model/TestDomain.hpp | 6 ++-- test/plugins/xml/XmlParserTest.cpp | 41 +++++++++++++++++++++-- testdata/xmlparser/book_domain.oxm | 3 ++ 8 files changed, 132 insertions(+), 115 deletions(-) diff --git a/src/core/model/Domain.cpp b/src/core/model/Domain.cpp index f8c0779..3284759 100644 --- a/src/core/model/Domain.cpp +++ b/src/core/model/Domain.cpp @@ -128,11 +128,9 @@ bool FieldDescriptor::removeChild(Handle c) void Descriptor::doResolve(ResolutionState &state) { - if (attributesDescriptor != nullptr) { - const NodeVector &attributes = - attributesDescriptor->getAttributes(); - continueResolveComposita(attributes, attributes.getIndex(), state); - } + const NodeVector &attributes = + attributesDescriptor->getAttributes(); + continueResolveComposita(attributes, attributes.getIndex(), state); continueResolveComposita(fieldDescriptors, fieldDescriptors.getIndex(), state); } @@ -155,8 +153,9 @@ bool Descriptor::doValidate(Logger &logger) const } else { valid = valid & validateName(logger); } - // check the FieldDescriptors themselves. - return valid & continueValidationCheckDuplicates(fieldDescriptors, logger); + // check attributes and the FieldDescriptors + return valid & attributesDescriptor->validate(logger) & + continueValidationCheckDuplicates(fieldDescriptors, logger); } std::vector> Descriptor::pathTo( @@ -235,7 +234,6 @@ bool Descriptor::continuePath(Handle target, return found; } - void Descriptor::addFieldDescriptor(Handle fd) { // only add it if we need to. @@ -319,18 +317,18 @@ Rooted Descriptor::createFieldDescriptor( StructuredClass::StructuredClass(Manager &mgr, std::string name, Handle domain, Variant cardinality, - Handle attributesDescriptor, Handle superclass, bool transparent, bool root) - : Descriptor(mgr, std::move(name), domain, attributesDescriptor), + : Descriptor(mgr, std::move(name), domain), cardinality(std::move(cardinality)), superclass(acquire(superclass)), subclasses(this), transparent(transparent), root(root) { + ExceptionLogger logger; if (superclass != nullptr) { - superclass->addSubclass(this); + superclass->addSubclass(this, logger); } if (domain != nullptr) { domain->addStructuredClass(this); @@ -368,21 +366,26 @@ bool StructuredClass::doValidate(Logger &logger) const return valid & Descriptor::doValidate(logger); } -void StructuredClass::setSuperclass(Handle sup) +void StructuredClass::setSuperclass(Handle sup, Logger &logger) { if (superclass == sup) { return; } // remove this subclass from the old superclass. if (superclass != nullptr) { - superclass->removeSubclass(this); + superclass->removeSubclass(this, logger); } // set the new superclass superclass = acquire(sup); invalidate(); // add this class as new subclass of the new superclass. if (sup != nullptr) { - sup->addSubclass(this); + sup->addSubclass(this, logger); + // set the attribute descriptor supertype + getAttributesDescriptor()->setParentStructure( + sup->getAttributesDescriptor(), logger); + } else { + getAttributesDescriptor()->setParentStructure(nullptr, logger); } } @@ -397,17 +400,20 @@ bool StructuredClass::isSubclassOf(Handle c) const return superclass->isSubclassOf(c); } -void StructuredClass::addSubclass(Handle sc) +void StructuredClass::addSubclass(Handle sc, Logger &logger) { + if (sc == nullptr) { + return; + } // check if we already have that class. if (subclasses.find(sc) == subclasses.end()) { invalidate(); subclasses.push_back(sc); } - sc->setSuperclass(this); + sc->setSuperclass(this, logger); } -void StructuredClass::removeSubclass(Handle sc) +void StructuredClass::removeSubclass(Handle sc, Logger &logger) { // if we don't have this subclass we can return directly. if (sc == nullptr) { @@ -420,7 +426,7 @@ void StructuredClass::removeSubclass(Handle sc) // otherwise we have to erase it. invalidate(); subclasses.erase(it); - sc->setSuperclass(nullptr); + sc->setSuperclass(nullptr, logger); } const void StructuredClass::gatherFieldDescriptors( @@ -450,13 +456,11 @@ NodeVector StructuredClass::getEffectiveFieldDescriptors() /* Class AnnotationClass */ -AnnotationClass::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) +AnnotationClass::AnnotationClass(Manager &mgr, std::string name, + Handle domain) + : Descriptor(mgr, std::move(name), domain) { - if (!domain.isNull()) { + if (domain != nullptr) { domain->addAnnotationClass(this); } } @@ -525,14 +529,12 @@ bool Domain::removeStructuredClass(Handle s) } Rooted Domain::createStructuredClass( - std::string name, Variant cardinality, - Handle attributesDescriptor, Handle superclass, + std::string name, Variant cardinality, Handle superclass, bool transparent, bool root) { return Rooted{new StructuredClass( - getManager(), std::move(name), this, std::move(cardinality), - attributesDescriptor, superclass, std::move(transparent), - std::move(root))}; + getManager(), std::move(name), this, std::move(cardinality), superclass, + std::move(transparent), std::move(root))}; } void Domain::addAnnotationClass(Handle a) @@ -564,11 +566,10 @@ bool Domain::removeAnnotationClass(Handle a) return false; } -Rooted Domain::createAnnotationClass( - std::string name, Handle attributesDescriptor) +Rooted Domain::createAnnotationClass(std::string name) { - return Rooted{new AnnotationClass( - getManager(), std::move(name), this, attributesDescriptor)}; + return Rooted{ + new AnnotationClass(getManager(), std::move(name), this)}; } /* Type registrations */ diff --git a/src/core/model/Domain.hpp b/src/core/model/Domain.hpp index dd0af4c..cd05441 100644 --- a/src/core/model/Domain.hpp +++ b/src/core/model/Domain.hpp @@ -217,7 +217,6 @@ class Descriptor; class StructuredClass; class Domain; - static const std::string DEFAULT_FIELD_NAME = "$default"; /** @@ -292,7 +291,8 @@ public: * Descriptor to be valid. */ FieldDescriptor(Manager &mgr, Handle parent, - Handle primitiveType, std::string name = DEFAULT_FIELD_NAME, + Handle primitiveType, + std::string name = DEFAULT_FIELD_NAME, bool optional = false); /** @@ -312,7 +312,8 @@ public: */ FieldDescriptor(Manager &mgr, Handle parent = nullptr, FieldType fieldType = FieldType::TREE, - std::string name = DEFAULT_FIELD_NAME, bool optional = false); + std::string name = DEFAULT_FIELD_NAME, + bool optional = false); /** * Returns a const reference to the NodeVector of StructuredClasses whose @@ -464,10 +465,9 @@ protected: bool doValidate(Logger &logger) const override; public: - Descriptor(Manager &mgr, std::string name, Handle domain, - Handle attributesDescriptor) + Descriptor(Manager &mgr, std::string name, Handle domain) : Node(mgr, std::move(name), domain), - attributesDescriptor(acquire(attributesDescriptor)), + attributesDescriptor(acquire(new StructType(mgr, "", nullptr))), fieldDescriptors(this) { } @@ -484,17 +484,6 @@ public: return attributesDescriptor; } - /** - * Sets the StructType that specifies the attributes of this Descriptor. - * - * @param t some StructType. - */ - void setAttributesDescriptor(Handle t) - { - invalidate(); - attributesDescriptor = acquire(t); - } - /** * Returns a const reference to the NodeVector of all FieldDescriptors of * this Descriptor. @@ -602,8 +591,7 @@ public: */ Rooted createFieldDescriptor( FieldDescriptor::FieldType fieldType = FieldDescriptor::FieldType::TREE, - std::string name = DEFAULT_FIELD_NAME, - bool optional = false); + std::string name = DEFAULT_FIELD_NAME, bool optional = false); /** * This tries to construct the shortest possible path of this Descriptor @@ -748,9 +736,6 @@ public: * have at least one author. This is set to * * per default, meaning that any number of * of instances is valid, including zero. - * @param attributesDescriptor is a StructType that specifies the attribute - * keys as well as value domains for this - * Descriptor. * @param superclass references a parent StructuredClass. Please * look for more information on inheritance in * the class documentation above. The default is @@ -767,7 +752,6 @@ public: StructuredClass(Manager &mgr, std::string name, Handle domain = nullptr, Variant cardinality = AnyCardinality, - Handle attributesDescriptor = nullptr, Handle superclass = nullptr, bool transparent = false, bool root = false); @@ -793,10 +777,15 @@ public: * This will also register this class as a subclass at the given superclass * and unregister it at the previous superclass. * - * @parem sup some StructuredClass that shall be the new superclass of this - * StructuredClass. + * It will also set the parent for this Descriptors AttributesDescriptor. + * + * @param sup some StructuredClass that shall be the new superclass of + * this StructuredClass. + * @param logger is some logger. Errors during setting the parent for this + * Descriptors AttributesDescriptor will be written into this + * logger. */ - void setSuperclass(Handle sup); + void setSuperclass(Handle sup, Logger &logger); /** * Returns true if this class is a subclass of the given class. It does not @@ -832,16 +821,22 @@ public: * on the given subclass. * * @param sc is some StructuredClass. + * @param logger is some logger. Errors during setting the parent for the + * new subclasses AttributesDescriptor will be written into + * this logger. */ - void addSubclass(Handle sc); + void addSubclass(Handle sc, Logger& logger); /** * Removes a subclass from this StructuredClass. This also calls * setSuperclass(nullptr) on the given subclass. * * @param sc is some StructuredClass. + * @param logger is some logger. Errors during setting the parent for the + * removed subclasses AttributesDescriptor will be written + * into this logger. */ - void removeSubclass(Handle sc); + void removeSubclass(Handle sc, Logger& logger); /** * Returns a const reference to the NodeVector of all FieldDescriptors of @@ -891,13 +886,8 @@ public: * AnnotationClass. * @param domain is the Domain this AnnotationClass belongs * to. - * @param attributesDescriptor is a StructType that specifies the attribute - * keys as well as value domains for this - * Descriptor. */ - AnnotationClass(Manager &mgr, std::string name, Handle domain, - // TODO: What would be a wise default value for attributes? - Handle attributesDescriptor = nullptr); + AnnotationClass(Manager &mgr, std::string name, Handle domain); }; /** @@ -1004,9 +994,6 @@ public: * have at least one author. This is set to * * per default, meaning that any number of * of instances is valid, including zero. - * @param attributesDescriptor is a StructType that specifies the attribute - * keys as well as value domains for this - * Descriptor. * @param superclass references a parent StructuredClass. Please * look for more information on inheritance in * the class documentation above. The default is @@ -1024,7 +1011,6 @@ public: */ Rooted createStructuredClass( std::string name, Variant cardinality = AnyCardinality, - Handle attributesDescriptor = nullptr, Handle superclass = nullptr, bool transparent = false, bool root = false); @@ -1064,12 +1050,8 @@ public: * @param name is a name for this AnnotationClass that will * be used for later references to this * AnnotationClass. - * @param attributesDescriptor is a StructType that specifies the attribute - * keys as well as value domains for this - * Descriptor. */ - Rooted createAnnotationClass( - std::string name, Handle attributesDescriptor = nullptr); + Rooted createAnnotationClass(std::string name); /** * Returns a const reference to the NodeVector of TypeSystems that are diff --git a/test/core/model/DocumentTest.cpp b/test/core/model/DocumentTest.cpp index 5a2bcec..177f69b 100644 --- a/test/core/model/DocumentTest.cpp +++ b/test/core/model/DocumentTest.cpp @@ -123,7 +123,7 @@ TEST(Document, validate) single.merge({1}); // Set up the "root" StructuredClass. Rooted rootClass{new StructuredClass( - mgr, "root", domain, single, {nullptr}, {nullptr}, false, true)}; + mgr, "root", domain, single, {nullptr}, false, true)}; // set up a document for it. { @@ -177,8 +177,8 @@ TEST(Document, validate) /* * Add a further extension to the domain: We add a subclass to child. */ - Rooted childSubClass{new StructuredClass( - mgr, "childSub", domain, single, {nullptr}, childClass)}; + Rooted childSubClass{ + new StructuredClass(mgr, "childSub", domain, single, childClass)}; { /* * A document with one instance of the Child subclass should be valid. @@ -284,23 +284,19 @@ TEST(Document, validate) ASSERT_EQ(ValidationState::UNKNOWN, doc->getValidationState()); ASSERT_TRUE(doc->validate(logger)); // add an attribute to the root, which should make it invalid. - root->setAttributes({2}); + root->setAttributes(Variant::mapType{{"bla", 2}}); ASSERT_EQ(ValidationState::UNKNOWN, doc->getValidationState()); ASSERT_FALSE(doc->validate(logger)); - // if we reset it to null it should be valid again - root->setAttributes({}); + // if we reset it to an empty map it should be valid again + root->setAttributes(Variant::mapType{}); ASSERT_EQ(ValidationState::UNKNOWN, doc->getValidationState()); ASSERT_TRUE(doc->validate(logger)); // let's set an attribute descriptor. - Rooted structType{StructType::createValidated( - mgr, "attributes", nullptr, nullptr, - NodeVector{ - new Attribute{mgr, "myAttr", sys->getStringType(), "default"}}, - logger)}; - childSubClass->setAttributesDescriptor(structType); + childSubClass->getAttributesDescriptor()->addAttribute( + new Attribute{mgr, "myAttr", sys->getStringType(), "default"}, + logger); // the right map content should be valid now. - child->setAttributes( - std::map{{"myAttr", "content"}}); + child->setAttributes(Variant::mapType{{"myAttr", "content"}}); ASSERT_EQ(ValidationState::UNKNOWN, doc->getValidationState()); ASSERT_TRUE(doc->validate(logger)); // but an empty map as well diff --git a/test/core/model/DomainTest.cpp b/test/core/model/DomainTest.cpp index 69c6694..8fcd21d 100644 --- a/test/core/model/DomainTest.cpp +++ b/test/core/model/DomainTest.cpp @@ -154,22 +154,22 @@ TEST(Descriptor, pathToAdvanced) // Let's create the classes that we need first Rooted A{new StructuredClass( - mgr, "A", domain, AnyCardinality, {nullptr}, {nullptr}, false, true)}; + mgr, "A", domain, AnyCardinality, {nullptr}, false, true)}; Rooted start{new StructuredClass( - mgr, "start", domain, AnyCardinality, {nullptr}, A, false, false)}; + mgr, "start", domain, AnyCardinality, A, false, false)}; Rooted B{new StructuredClass( - mgr, "B", domain, AnyCardinality, {nullptr}, {nullptr}, true, false)}; + mgr, "B", domain, AnyCardinality, {nullptr}, true, false)}; - Rooted C{new StructuredClass( - mgr, "C", domain, AnyCardinality, {nullptr}, B, true, false)}; + Rooted C{ + new StructuredClass(mgr, "C", domain, AnyCardinality, B, true, false)}; Rooted D{new StructuredClass( - mgr, "D", domain, AnyCardinality, {nullptr}, {nullptr}, true, false)}; + mgr, "D", domain, AnyCardinality, {nullptr}, true, false)}; Rooted E{new StructuredClass( - mgr, "E", domain, AnyCardinality, {nullptr}, {nullptr}, true, false)}; + mgr, "E", domain, AnyCardinality, {nullptr}, true, false)}; Rooted target{ new StructuredClass(mgr, "target", domain, AnyCardinality)}; @@ -223,19 +223,19 @@ TEST(StructuredClass, isSubclassOf) Rooted sys{new SystemTypesystem(mgr)}; Rooted domain{new Domain(mgr, sys, "inheritance")}; Rooted A{new StructuredClass( - mgr, "A", domain, AnyCardinality, {nullptr}, {nullptr}, false, true)}; + mgr, "A", domain, AnyCardinality, {nullptr}, false, true)}; // first branch Rooted B{ - new StructuredClass(mgr, "B", domain, AnyCardinality, {nullptr}, A)}; + new StructuredClass(mgr, "B", domain, AnyCardinality, A)}; Rooted C{ - new StructuredClass(mgr, "C", domain, AnyCardinality, {nullptr}, B)}; + new StructuredClass(mgr, "C", domain, AnyCardinality, B)}; // second branch Rooted D{ - new StructuredClass(mgr, "D", domain, AnyCardinality, {nullptr}, A)}; + new StructuredClass(mgr, "D", domain, AnyCardinality, A)}; Rooted E{ - new StructuredClass(mgr, "E", domain, AnyCardinality, {nullptr}, D)}; + new StructuredClass(mgr, "E", domain, AnyCardinality, D)}; Rooted F{ - new StructuredClass(mgr, "F", domain, AnyCardinality, {nullptr}, D)}; + new StructuredClass(mgr, "F", domain, AnyCardinality, D)}; // check function results ASSERT_FALSE(A->isSubclassOf(A)); @@ -335,16 +335,16 @@ TEST(Domain, validate) ASSERT_EQ(ValidationState::UNKNOWN, domain->getValidationState()); ASSERT_TRUE(domain->validate(logger)); // and still if we add a superclass. - sub->setSuperclass(base); + sub->setSuperclass(base, logger); ASSERT_EQ(ValidationState::UNKNOWN, domain->getValidationState()); ASSERT_TRUE(domain->validate(logger)); // and still we we remove the subclass from the base class. - base->removeSubclass(sub); + base->removeSubclass(sub, logger); ASSERT_EQ(ValidationState::UNKNOWN, domain->getValidationState()); ASSERT_TRUE(domain->validate(logger)); ASSERT_EQ(nullptr, sub->getSuperclass()); // and still if we re-add it. - base->addSubclass(sub); + base->addSubclass(sub, logger); ASSERT_EQ(ValidationState::UNKNOWN, domain->getValidationState()); ASSERT_TRUE(domain->validate(logger)); ASSERT_EQ(base, sub->getSuperclass()); diff --git a/test/core/model/TestAdvanced.hpp b/test/core/model/TestAdvanced.hpp index 3845676..2e4a541 100644 --- a/test/core/model/TestAdvanced.hpp +++ b/test/core/model/TestAdvanced.hpp @@ -56,7 +56,7 @@ static Rooted constructHeadingDomain(Manager &mgr, card.merge({0, 1}); // set up heading StructuredClass. Rooted heading{new StructuredClass( - mgr, "heading", domain, card, {nullptr}, {nullptr}, true)}; + mgr, "heading", domain, card, {nullptr}, true)}; // as field want to copy the field of paragraph. Rooted p = resolveDescriptor(bookDomain, "paragraph"); heading->copyFieldDescriptor(p->getFieldDescriptors()[0]); @@ -86,7 +86,7 @@ static Rooted constructListDomain(Manager &mgr, Rooted p = resolveDescriptor(bookDomain, "paragraph"); // set up item StructuredClass; Rooted item{new StructuredClass( - mgr, "item", domain, AnyCardinality, {nullptr}, {nullptr}, false)}; + mgr, "item", domain, AnyCardinality, {nullptr}, false)}; // as field we want to copy the field of paragraph. item->copyFieldDescriptor(p->getFieldDescriptors()[0]); @@ -94,7 +94,7 @@ static Rooted constructListDomain(Manager &mgr, std::vector listTypes{"ol", "ul"}; for (auto &listType : listTypes) { Rooted list{new StructuredClass( - mgr, listType, domain, AnyCardinality, {nullptr}, p, false)}; + mgr, listType, domain, AnyCardinality, p, false)}; Rooted list_field{new FieldDescriptor(mgr, list)}; list_field->addChild(item); } diff --git a/test/core/model/TestDomain.hpp b/test/core/model/TestDomain.hpp index 88ab715..18c42bd 100644 --- a/test/core/model/TestDomain.hpp +++ b/test/core/model/TestDomain.hpp @@ -39,7 +39,7 @@ static Rooted constructBookDomain(Manager &mgr, // Set up the "book" node. Rooted book{new StructuredClass( - mgr, "book", domain, single, {nullptr}, {nullptr}, false, true)}; + mgr, "book", domain, single, {nullptr}, false, true)}; // The structure field of it. Rooted book_field{new FieldDescriptor(mgr, book)}; @@ -54,7 +54,7 @@ static Rooted constructBookDomain(Manager &mgr, // We also add the "paragraph", which is transparent. Rooted paragraph{new StructuredClass( - mgr, "paragraph", domain, AnyCardinality, {nullptr}, {nullptr}, true)}; + mgr, "paragraph", domain, AnyCardinality, {nullptr}, true)}; section_field->addChild(paragraph); book_field->addChild(paragraph); @@ -76,7 +76,7 @@ static Rooted constructBookDomain(Manager &mgr, // Finally we add the "text" node, which is transparent as well. Rooted text{new StructuredClass( - mgr, "text", domain, AnyCardinality, {nullptr}, {nullptr}, true)}; + mgr, "text", domain, AnyCardinality, {nullptr}, true)}; paragraph_field->addChild(text); // ... and has a primitive field. diff --git a/test/plugins/xml/XmlParserTest.cpp b/test/plugins/xml/XmlParserTest.cpp index 0512fd0..647fc6d 100644 --- a/test/plugins/xml/XmlParserTest.cpp +++ b/test/plugins/xml/XmlParserTest.cpp @@ -74,6 +74,27 @@ TEST(XmlParser, generic) #endif } +static void checkAttributes(Handle expected, + Handle desc) +{ + if (expected == nullptr) { + ASSERT_TRUE(desc->getAttributesDescriptor()->getAttributes().empty()); + } else { + ASSERT_EQ(expected->getName(), + desc->getAttributesDescriptor()->getName()); + auto &attrs_exp = expected->getAttributes(); + auto &attrs = desc->getAttributesDescriptor()->getAttributes(); + ASSERT_EQ(attrs_exp.size(), attrs.size()); + for (size_t i = 0; i < attrs_exp.size(); i++) { + ASSERT_EQ(attrs_exp[i]->getName(), attrs[i]->getName()); + ASSERT_EQ(attrs_exp[i]->getType(), attrs[i]->getType()); + ASSERT_EQ(attrs_exp[i]->isOptional(), attrs[i]->isOptional()); + ASSERT_EQ(attrs_exp[i]->getDefaultValue(), + attrs[i]->getDefaultValue()); + } + } +} + static void checkStructuredClass( Handle n, const std::string &name, Handle domain, Variant cardinality = AnyCardinality, @@ -89,7 +110,7 @@ static void checkStructuredClass( ASSERT_EQ(cardinality, sc->getCardinality()); ASSERT_EQ(transparent, sc->isTransparent()); ASSERT_EQ(root, sc->hasRootPermission()); - ASSERT_EQ(attributesDescriptor, sc->getAttributesDescriptor()); + checkAttributes(attributesDescriptor, sc); } static Rooted checkStructuredClass( @@ -118,7 +139,7 @@ static void checkAnnotationClass( ASSERT_FALSE(ac == nullptr); ASSERT_EQ(name, ac->getName()); ASSERT_EQ(domain, ac->getParent()); - ASSERT_EQ(attributesDescriptor, ac->getAttributesDescriptor()); + checkAttributes(attributesDescriptor, ac); } static Rooted checkAnnotationClass( @@ -191,8 +212,15 @@ TEST(XmlParser, domainParsing) // get the book struct node. Cardinality single; single.merge({1}); + Rooted bookAuthor{ + new StructType(book_domain->getManager(), "", nullptr)}; + bookAuthor->addAttribute( + {new Attribute(book_domain->getManager(), "author", + env.project->getSystemTypesystem()->getStringType(), + "")}, + logger); Rooted book = checkStructuredClass( - "book", "book", book_domain, single, nullptr, nullptr, false, true); + "book", "book", book_domain, single, bookAuthor, nullptr, false, true); // get the chapter struct node. Rooted chapter = checkStructuredClass("chapter", "chapter", book_domain); @@ -274,5 +302,12 @@ TEST(XmlParser, domainParsing) // as should heading, because it references the paragraph default field. checkFieldDescriptor(heading, paragraph, {text, comment}); } + +TEST(XmlParser, documentParsing) +{ + XmlStandaloneEnvironment env(logger); + Rooted book_domain_node = + env.parse("simple_book.oxd", "", "", RttiSet{&RttiTypes::Document}); +} } diff --git a/testdata/xmlparser/book_domain.oxm b/testdata/xmlparser/book_domain.oxm index e02ec53..ed9309b 100644 --- a/testdata/xmlparser/book_domain.oxm +++ b/testdata/xmlparser/book_domain.oxm @@ -10,6 +10,9 @@ values. Also note that we need to specify explicitly, which classes are allowed as root nodes. --> + + +