From ec56144613e47cea2636b7179f3a8b27eacdba50 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Thu, 10 Aug 2023 23:16:36 +0100 Subject: Move private stuff into anon namespace --- slicer/xml/serializer.cpp | 687 +++++++++++++++++++++++----------------------- slicer/xml/serializer.h | 37 +-- 2 files changed, 355 insertions(+), 369 deletions(-) diff --git a/slicer/xml/serializer.cpp b/slicer/xml/serializer.cpp index f9cb045..f508a6f 100644 --- a/slicer/xml/serializer.cpp +++ b/slicer/xml/serializer.cpp @@ -10,16 +10,16 @@ #endif #include #include +#include #include #include #include +#include #pragma GCC diagnostic pop #include #include #include #include -#include -#include #include #include #include @@ -37,411 +37,426 @@ NAMEDFACTORY("application/xml", Slicer::XmlStreamSerializer, Slicer::StreamSeria NAMEDFACTORY("application/xml", Slicer::XmlStreamDeserializer, Slicer::StreamDeserializerFactory) namespace Slicer { - constexpr std::string_view md_attribute {"xml:attribute"}; - constexpr std::string_view md_text {"xml:text"}; - constexpr std::string_view md_bare {"xml:bare"}; - constexpr std::string_view md_attributes {"xml:attributes"}; - constexpr std::string_view md_elements {"xml:elements"}; - constexpr std::string_view keyName {"key"}; - constexpr std::string_view valueName {"value"}; - - constexpr auto defaultElementCreator = [](auto && element, auto && name) { - return element->add_child_element(name); - }; + namespace { + constexpr std::string_view md_attribute {"xml:attribute"}; + constexpr std::string_view md_text {"xml:text"}; + constexpr std::string_view md_bare {"xml:bare"}; + constexpr std::string_view md_attributes {"xml:attributes"}; + constexpr std::string_view md_elements {"xml:elements"}; + constexpr std::string_view keyName {"key"}; + constexpr std::string_view valueName {"value"}; + + using CurrentElementCreator = ::AdHoc::LazyPointer; + using ElementCreator = std::function; + + constexpr auto defaultElementCreator = [](auto && element, auto && name) { + return element->add_child_element(name); + }; - static const Glib::ustring TrueText("true"); - static const Glib::ustring FalseText("false"); + const Glib::ustring TrueText("true"); + const Glib::ustring FalseText("false"); - class XmlValueSource : public ValueSource { - public: - explicit XmlValueSource(Glib::ustring s) : value(std::move(s)) { } + class XmlValueSource : public ValueSource { + public: + explicit XmlValueSource(Glib::ustring s) : value(std::move(s)) { } - void - set(bool & v) const override - { - if (value == TrueText) { - v = true; - return; - } - if (value == FalseText) { - v = false; - return; + void + set(bool & v) const override + { + if (value == TrueText) { + v = true; + return; + } + if (value == FalseText) { + v = false; + return; + } + throw BadBooleanValue(value); } - throw BadBooleanValue(value); - } - void - set(Ice::Byte & v) const override - { - from_chars(v); - } + void + set(Ice::Byte & v) const override + { + from_chars(v); + } - void - set(Ice::Short & v) const override - { - from_chars(v); - } + void + set(Ice::Short & v) const override + { + from_chars(v); + } - void - set(Ice::Int & v) const override - { - from_chars(v); - } + void + set(Ice::Int & v) const override + { + from_chars(v); + } - void - set(Ice::Long & v) const override - { - from_chars(v); - } + void + set(Ice::Long & v) const override + { + from_chars(v); + } - void - set(Ice::Float & v) const override - { - from_chars(v); - } + void + set(Ice::Float & v) const override + { + from_chars(v); + } - void - set(Ice::Double & v) const override - { - from_chars(v); - } + void + set(Ice::Double & v) const override + { + from_chars(v); + } - void - set(std::string & v) const override - { - v = value.raw(); - } + void + set(std::string & v) const override + { + v = value.raw(); + } - private: - template - void - from_chars(T & v) const - { - std::string_view raw {value.raw()}; - if (std::from_chars(raw.begin(), raw.end(), v).ec != std::errc {}) { - throw BadNumericValue(value); + private: + template + void + from_chars(T & v) const + { + std::string_view raw {value.raw()}; + if (std::from_chars(raw.begin(), raw.end(), v).ec != std::errc {}) { + throw BadNumericValue(value); + } } - } - const Glib::ustring value; - }; + const Glib::ustring value; + }; - class XmlContentValueSource : public XmlValueSource { - public: - explicit XmlContentValueSource() : XmlValueSource(Glib::ustring()) { } + class XmlContentValueSource : public XmlValueSource { + public: + explicit XmlContentValueSource() : XmlValueSource(Glib::ustring()) { } - explicit XmlContentValueSource(const xmlpp::ContentNode * c) : XmlValueSource(c->get_content()) { } - }; + explicit XmlContentValueSource(const xmlpp::ContentNode * c) : XmlValueSource(c->get_content()) { } + }; - class XmlAttributeValueSource : public XmlValueSource { - public: - explicit XmlAttributeValueSource(const xmlpp::Attribute * a) : XmlValueSource(a->get_value()) { } - }; + class XmlAttributeValueSource : public XmlValueSource { + public: + explicit XmlAttributeValueSource(const xmlpp::Attribute * a) : XmlValueSource(a->get_value()) { } + }; - class XmlValueTarget : public ValueTarget { - public: - explicit XmlValueTarget(std::function a) : apply(std::move(a)) { } + class XmlValueTarget : public ValueTarget { + public: + explicit XmlValueTarget(std::function a) : apply(std::move(a)) { } - void - get(const bool & value) const override - { - if (value) { - apply(TrueText); + void + get(const bool & value) const override + { + if (value) { + apply(TrueText); + } + else { + apply(FalseText); + } } - else { - apply(FalseText); + + void + get(const Ice::Byte & value) const override + { + apply(Glib::ustring::format(value)); } - } - void - get(const Ice::Byte & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const Ice::Short & value) const override + { + apply(Glib::ustring::format(value)); + } - void - get(const Ice::Short & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const Ice::Int & value) const override + { + apply(Glib::ustring::format(value)); + } - void - get(const Ice::Int & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const Ice::Long & value) const override + { + apply(Glib::ustring::format(value)); + } - void - get(const Ice::Long & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const Ice::Float & value) const override + { + apply(Glib::ustring::format(value)); + } - void - get(const Ice::Float & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const Ice::Double & value) const override + { + apply(Glib::ustring::format(value)); + } - void - get(const Ice::Double & value) const override - { - apply(Glib::ustring::format(value)); - } + void + get(const std::string & value) const override + { + apply(value); + } - void - get(const std::string & value) const override - { - apply(value); - } + private: + const std::function apply; + }; - private: - const std::function apply; - }; + class XmlAttributeValueTarget : public XmlValueTarget { + public: + explicit XmlAttributeValueTarget(xmlpp::Element * p, const std::string & n) : + XmlValueTarget([p, n](auto && PH1) { + p->set_attribute(n, PH1); + }) + { + } + }; - class XmlAttributeValueTarget : public XmlValueTarget { - public: - explicit XmlAttributeValueTarget(xmlpp::Element * p, const std::string & n) : - XmlValueTarget([p, n](auto && PH1) { - p->set_attribute(n, PH1); - }) - { - } - }; - - class XmlContentValueTarget : public XmlValueTarget { - public: - explicit XmlContentValueTarget(xmlpp::Element * p) : - XmlValueTarget([p](auto && PH1) { - p->set_first_child_text(PH1); - }) - { - } + class XmlContentValueTarget : public XmlValueTarget { + public: + explicit XmlContentValueTarget(xmlpp::Element * p) : + XmlValueTarget([p](auto && PH1) { + p->set_first_child_text(PH1); + }) + { + } - explicit XmlContentValueTarget(const CurrentElementCreator & cec) : - XmlValueTarget([&](auto && PH1) { - cec->set_first_child_text(PH1); - }) - { - } - }; + explicit XmlContentValueTarget(const CurrentElementCreator & cec) : + XmlValueTarget([&](auto && PH1) { + cec->set_first_child_text(PH1); + }) + { + } + }; - void - XmlDeserializer::DocumentTreeIterateDictAttrs( - const xmlpp::Element::const_AttributeList & attrs, ModelPartParam dict) - { - for (const auto & attr : attrs) { - auto emp = dict->GetAnonChild(); - emp->Create(); - auto key = emp->GetChild(keyName); - auto value = emp->GetChild(valueName); - key->SetValue(XmlValueSource(attr->get_name())); - key->Complete(); - value->SetValue(XmlValueSource(attr->get_value())); - value->Complete(); - emp->Complete(); - } - } + void DocumentTreeIterate(const xmlpp::Node * node, ModelPartParam mp); + void DocumentTreeIterateElement(const xmlpp::Element * element, ModelPartParam mp, const ChildRef & c); + void DocumentTreeIterate(const xmlpp::Document * doc, ModelPartParam mp); + void DocumentTreeIterateDictAttrs(const xmlpp::Element::const_AttributeList & attrs, ModelPartParam dict); + void DocumentTreeIterateDictElements(const xmlpp::Element * parent, ModelPartParam dict); - void - XmlDeserializer::DocumentTreeIterateDictElements(const xmlpp::Element * element, ModelPartParam dict) - { - auto node = element->get_first_child(); - while (node) { - if (auto childElement = dynamic_cast(node)) { + void + DocumentTreeIterateDictAttrs(const xmlpp::Element::const_AttributeList & attrs, ModelPartParam dict) + { + for (const auto & attr : attrs) { auto emp = dict->GetAnonChild(); emp->Create(); auto key = emp->GetChild(keyName); - auto value = emp->GetChildRef(valueName); - key->SetValue(XmlValueSource(childElement->get_name())); + auto value = emp->GetChild(valueName); + key->SetValue(XmlValueSource(attr->get_name())); key->Complete(); - DocumentTreeIterateElement(childElement, value.Child(), value); + value->SetValue(XmlValueSource(attr->get_value())); + value->Complete(); emp->Complete(); } - node = node->get_next_sibling(); } - } - void - XmlDeserializer::DocumentTreeIterateElement( - const xmlpp::Element * element, ModelPartParam smp, const ChildRef & smpr) - { - auto oec = [&smpr, element](const auto & lmp) { - lmp->Create(); - if (smpr.ChildMetaData().flagSet(md_attributes)) { - auto attrs(element->get_attributes()); - if (!attrs.empty()) { - DocumentTreeIterateDictAttrs(attrs, lmp); + void + DocumentTreeIterateDictElements(const xmlpp::Element * element, ModelPartParam dict) + { + auto node = element->get_first_child(); + while (node) { + if (auto childElement = dynamic_cast(node)) { + auto emp = dict->GetAnonChild(); + emp->Create(); + auto key = emp->GetChild(keyName); + auto value = emp->GetChildRef(valueName); + key->SetValue(XmlValueSource(childElement->get_name())); + key->Complete(); + DocumentTreeIterateElement(childElement, value.Child(), value); + emp->Complete(); } + node = node->get_next_sibling(); } - else if (smpr.ChildMetaData().flagSet(md_elements)) { - DocumentTreeIterateDictElements(element, lmp); - } - else { - auto attrs(element->get_attributes()); - if (!attrs.empty()) { - DocumentTreeIterate(attrs.front(), lmp); + } + + void + DocumentTreeIterateElement(const xmlpp::Element * element, ModelPartParam smp, const ChildRef & smpr) + { + auto oec = [&smpr, element](const auto & lmp) { + lmp->Create(); + if (smpr.ChildMetaData().flagSet(md_attributes)) { + auto attrs(element->get_attributes()); + if (!attrs.empty()) { + DocumentTreeIterateDictAttrs(attrs, lmp); + } } - auto firstChild = element->get_first_child(); - if (firstChild) { - DocumentTreeIterate(firstChild, lmp); + else if (smpr.ChildMetaData().flagSet(md_elements)) { + DocumentTreeIterateDictElements(element, lmp); } else { - lmp->SetValue(XmlContentValueSource()); + auto attrs(element->get_attributes()); + if (!attrs.empty()) { + DocumentTreeIterate(attrs.front(), lmp); + } + auto firstChild = element->get_first_child(); + if (firstChild) { + DocumentTreeIterate(firstChild, lmp); + } + else { + lmp->SetValue(XmlContentValueSource()); + } + } + lmp->Complete(); + }; + if (auto typeIdPropName = smp->GetTypeIdProperty()) { + if (auto typeAttr = element->get_attribute(*typeIdPropName)) { + oec(smp->GetSubclassModelPart(typeAttr->get_value())); + return; } } - lmp->Complete(); - }; - if (auto typeIdPropName = smp->GetTypeIdProperty()) { - if (auto typeAttr = element->get_attribute(*typeIdPropName)) { - oec(smp->GetSubclassModelPart(typeAttr->get_value())); - return; - } + oec(smp); } - oec(smp); - } - void - XmlDeserializer::DocumentTreeIterate(const xmlpp::Node * node, ModelPartParam mp) - { - while (node) { - if (auto element = dynamic_cast(node)) { - auto smpr = mp->GetChildRef(element->get_name().raw(), [](const auto & h) { - return h->GetMetadata().flagNotSet(md_attribute); - }); - if (smpr) { - auto smp = smpr.Child(); - if (smpr.ChildMetaData().flagSet(md_bare)) { - smp = smp->GetAnonChild(); + void + DocumentTreeIterate(const xmlpp::Node * node, ModelPartParam mp) + { + while (node) { + if (auto element = dynamic_cast(node)) { + auto smpr = mp->GetChildRef(element->get_name().raw(), [](const auto & h) { + return h->GetMetadata().flagNotSet(md_attribute); + }); + if (smpr) { + auto smp = smpr.Child(); + if (smpr.ChildMetaData().flagSet(md_bare)) { + smp = smp->GetAnonChild(); + } + if (smp) { + DocumentTreeIterateElement(element, smp, smpr); + } } + } + else if (auto attribute = dynamic_cast(node)) { + auto smp = mp->GetChild(attribute->get_name().raw(), [](const auto & h) { + return h->GetMetadata().flagSet(md_attribute); + }); if (smp) { - DocumentTreeIterateElement(element, smp, smpr); + smp->Create(); + smp->SetValue(XmlAttributeValueSource(attribute)); + smp->Complete(); } } - } - else if (auto attribute = dynamic_cast(node)) { - auto smp = mp->GetChild(attribute->get_name().raw(), [](const auto & h) { - return h->GetMetadata().flagSet(md_attribute); - }); - if (smp) { - smp->Create(); - smp->SetValue(XmlAttributeValueSource(attribute)); - smp->Complete(); + else if (auto content = dynamic_cast(node)) { + ModelPartPtr smp; + if (!content->is_white_space()) { + smp = mp->GetAnonChild([](const auto & h) { + return h->GetMetadata().flagSet(md_text); + }); + } + if (smp) { + smp->SetValue(XmlContentValueSource(content)); + } + else { + mp->SetValue(XmlContentValueSource(content)); + } } + node = node->get_next_sibling(); + } + } + + void + DocumentTreeIterate(const xmlpp::Document * doc, ModelPartParam mp) + { + DocumentTreeIterate(doc->get_root_node(), mp); + } + + void ModelTreeIterate(xmlpp::Element *, const std::string &, ModelPartParam mp, const HookCommon * hp, + const ElementCreator &); + void ModelTreeIterateRoot(xmlpp::Document *, const std::string &, ModelPartParam mp); + void ModelTreeProcessElement(const CurrentElementCreator &, ModelPartParam mp, const ElementCreator &); + void ModelTreeIterateDictAttrs(xmlpp::Element * element, ModelPartParam dict); + void ModelTreeIterateDictElements(xmlpp::Element * element, ModelPartParam dict); + + void + ModelTreeIterate(xmlpp::Element * n, const std::string & name, ModelPartParam mp, const HookCommon * hp, + const ElementCreator & ec) + { + if (name.empty()) { + return; + } + if (hp && hp->GetMetadata().flagSet(md_attribute)) { + mp->GetValue(XmlAttributeValueTarget(n, name)); + } + else if (hp && hp->GetMetadata().flagSet(md_text)) { + mp->GetValue(XmlContentValueTarget(n)); + } + else if (hp && hp->GetMetadata().flagSet(md_attributes)) { + ModelTreeIterateDictAttrs(n->add_child_element(name), mp); } - else if (auto content = dynamic_cast(node)) { - ModelPartPtr smp; - if (!content->is_white_space()) { - smp = mp->GetAnonChild([](const auto & h) { - return h->GetMetadata().flagSet(md_text); + else if (hp && hp->GetMetadata().flagSet(md_elements)) { + ModelTreeIterateDictElements(n->add_child_element(name), mp); + } + else { + if (hp && hp->GetMetadata().flagSet(md_bare)) { + ModelTreeProcessElement(n, mp, [name](auto && PH1, auto &&) { + return PH1->add_child_element(name); }); } - if (smp) { - smp->SetValue(XmlContentValueSource(content)); - } else { - mp->SetValue(XmlContentValueSource(content)); + CurrentElementCreator cec([ec, n, name] { + return ec(n, name); + }); + ModelTreeProcessElement(cec, mp, defaultElementCreator); } } - node = node->get_next_sibling(); } - } - void - XmlDeserializer::DocumentTreeIterate(const xmlpp::Document * doc, ModelPartParam mp) - { - DocumentTreeIterate(doc->get_root_node(), mp); - } - - void - XmlSerializer::ModelTreeIterate(xmlpp::Element * n, const std::string & name, ModelPartParam mp, - const HookCommon * hp, const ElementCreator & ec) - { - if (name.empty()) { - return; - } - if (hp && hp->GetMetadata().flagSet(md_attribute)) { - mp->GetValue(XmlAttributeValueTarget(n, name)); - } - else if (hp && hp->GetMetadata().flagSet(md_text)) { - mp->GetValue(XmlContentValueTarget(n)); - } - else if (hp && hp->GetMetadata().flagSet(md_attributes)) { - ModelTreeIterateDictAttrs(n->add_child_element(name), mp); - } - else if (hp && hp->GetMetadata().flagSet(md_elements)) { - ModelTreeIterateDictElements(n->add_child_element(name), mp); + void + ModelTreeIterateDictAttrs(xmlpp::Element * element, ModelPartParam dict) + { + dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { + if (mp->HasValue()) { + mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { + mp->GetChild(valueName)->GetValue(XmlAttributeValueTarget(element, name)); + })); + } + }); } - else { - if (hp && hp->GetMetadata().flagSet(md_bare)) { - ModelTreeProcessElement(n, mp, [name](auto && PH1, auto &&) { - return PH1->add_child_element(name); - }); - } - else { - CurrentElementCreator cec([ec, n, name] { - return ec(n, name); - }); - ModelTreeProcessElement(cec, mp, defaultElementCreator); - } + + void + ModelTreeIterateDictElements(xmlpp::Element * element, ModelPartParam dict) + { + dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { + if (mp->HasValue()) { + mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { + CurrentElementCreator cec([&element, &name]() { + return element->add_child_element(name); + }); + ModelTreeProcessElement(cec, mp->GetChild(valueName), defaultElementCreator); + })); + } + }); } - } - void - XmlSerializer::ModelTreeIterateDictAttrs(xmlpp::Element * element, ModelPartParam dict) - { - dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { - if (mp->HasValue()) { - mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { - mp->GetChild(valueName)->GetValue(XmlAttributeValueTarget(element, name)); - })); + void + ModelTreeProcessElement(const CurrentElementCreator & cec, ModelPartParam mp, const ElementCreator & ec) + { + if (mp->GetType() == ModelPartType::Simple) { + mp->GetValue(XmlContentValueTarget(cec)); } - }); - } - - void - XmlSerializer::ModelTreeIterateDictElements(xmlpp::Element * element, ModelPartParam dict) - { - dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { - if (mp->HasValue()) { - mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { - CurrentElementCreator cec([&element, &name]() { - return element->add_child_element(name); + else if (mp->HasValue()) { + auto oec = [element = cec.get(), &ec](const auto & lmp) { + lmp->OnEachChild([element, &ec](auto && PH1, auto && PH2, auto && PH3) { + return ModelTreeIterate(element, PH1, PH2, PH3, ec); }); - ModelTreeProcessElement(cec, mp->GetChild(valueName), defaultElementCreator); - })); - } - }); - } - - void - XmlSerializer::ModelTreeProcessElement( - const CurrentElementCreator & cec, ModelPartParam mp, const ElementCreator & ec) - { - if (mp->GetType() == ModelPartType::Simple) { - mp->GetValue(XmlContentValueTarget(cec)); - } - else if (mp->HasValue()) { - auto oec = [element = cec.get(), &ec](const auto & lmp) { - lmp->OnEachChild([element, &ec](auto && PH1, auto && PH2, auto && PH3) { - return XmlSerializer::ModelTreeIterate(element, PH1, PH2, PH3, ec); - }); - return element; - }; - if (auto typeIdPropName = mp->GetTypeIdProperty()) { - if (auto typeId = mp->GetTypeId()) { - oec(mp->GetSubclassModelPart(*typeId))->set_attribute(*typeIdPropName, *typeId); - return; + return element; + }; + if (auto typeIdPropName = mp->GetTypeIdProperty()) { + if (auto typeId = mp->GetTypeId()) { + oec(mp->GetSubclassModelPart(*typeId))->set_attribute(*typeIdPropName, *typeId); + return; + } } + oec(mp); } - oec(mp); } - } - void - XmlSerializer::ModelTreeIterateRoot(xmlpp::Document * doc, const std::string & name, ModelPartParam mp) - { - ModelTreeProcessElement(doc->create_root_node(name), mp, defaultElementCreator); + void + ModelTreeIterateRoot(xmlpp::Document * doc, const std::string & name, ModelPartParam mp) + { + ModelTreeProcessElement(doc->create_root_node(name), mp, defaultElementCreator); + } } XmlStreamSerializer::XmlStreamSerializer(std::ostream & s) : strm(s) { } @@ -488,7 +503,7 @@ namespace Slicer { XmlDocumentSerializer::Serialize(ModelPartForRootParam modelRoot) { modelRoot->OnEachChild([this](auto && PH1, auto && PH2, auto &&) { - return XmlSerializer::ModelTreeIterateRoot(&doc, PH1, PH2); + return ModelTreeIterateRoot(&doc, PH1, PH2); }); } diff --git a/slicer/xml/serializer.h b/slicer/xml/serializer.h index d138ac0..9c6e1ae 100644 --- a/slicer/xml/serializer.h +++ b/slicer/xml/serializer.h @@ -1,7 +1,6 @@ #ifndef SLICER_XML_H #define SLICER_XML_H -#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wsign-conversion" @@ -9,12 +8,9 @@ # pragma GCC diagnostic ignored "-Wuseless-cast" #endif #include -#include #pragma GCC diagnostic pop #include #include -#include -#include #include #include #include @@ -25,22 +21,7 @@ namespace Glib { } namespace Slicer { - using CurrentElementCreator = ::AdHoc::LazyPointer; - - class DLL_PUBLIC XmlSerializer : public Serializer { - protected: - using ElementCreator = std::function; - static void ModelTreeIterate(xmlpp::Element *, const std::string &, ModelPartParam mp, const HookCommon * hp, - const ElementCreator &); - static void ModelTreeIterateRoot(xmlpp::Document *, const std::string &, ModelPartParam mp); - - protected: - static void ModelTreeProcessElement(const CurrentElementCreator &, ModelPartParam mp, const ElementCreator &); - static void ModelTreeIterateDictAttrs(xmlpp::Element * element, ModelPartParam dict); - static void ModelTreeIterateDictElements(xmlpp::Element * element, ModelPartParam dict); - }; - - class DLL_PUBLIC XmlDocumentSerializer : public XmlSerializer { + class DLL_PUBLIC XmlDocumentSerializer : public Serializer { public: void Serialize(ModelPartForRootParam) override; @@ -66,17 +47,7 @@ namespace Slicer { std::ofstream strm; }; - class DLL_PUBLIC XmlDeserializer : public Deserializer { - protected: - static void DocumentTreeIterate(const xmlpp::Node * node, ModelPartParam mp); - static void DocumentTreeIterateElement(const xmlpp::Element * element, ModelPartParam mp, const ChildRef & c); - static void DocumentTreeIterate(const xmlpp::Document * doc, ModelPartParam mp); - static void DocumentTreeIterateDictAttrs( - const xmlpp::Element::const_AttributeList & attrs, ModelPartParam dict); - static void DocumentTreeIterateDictElements(const xmlpp::Element * parent, ModelPartParam dict); - }; - - class DLL_PUBLIC XmlStreamDeserializer : public XmlDeserializer { + class DLL_PUBLIC XmlStreamDeserializer : public Deserializer { public: explicit XmlStreamDeserializer(std::istream &); @@ -86,7 +57,7 @@ namespace Slicer { std::istream & strm; }; - class DLL_PUBLIC XmlFileDeserializer : public XmlDeserializer { + class DLL_PUBLIC XmlFileDeserializer : public Deserializer { public: explicit XmlFileDeserializer(std::filesystem::path); @@ -96,7 +67,7 @@ namespace Slicer { const std::filesystem::path path; }; - class DLL_PUBLIC XmlDocumentDeserializer : public XmlDeserializer { + class DLL_PUBLIC XmlDocumentDeserializer : public Deserializer { public: explicit XmlDocumentDeserializer(const xmlpp::Document *); -- cgit v1.2.3