zenxml/doc/dom_8h_source.html

 // **************************************************************************

- // * This file is part of the FreeFileSync project. It is distributed under *

- // * GNU General Public License: http://www.gnu.org/licenses/gpl.html       *

- // * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved        *

- // **************************************************************************

-

- #ifndef ZEN_XML_DOM_HEADER_82085720723894567204564256

- #define ZEN_XML_DOM_HEADER_82085720723894567204564256

-

- #include <string>

- #include <vector>

- #include <memory>

- #include <map>

- #include "cvrt_text.h" //"readText/writeText"

-

- namespace zen

- {

- class XmlDoc;

-

- class XmlElement

- {

-     struct PrivateConstruction {};

- public:

-     //Construct an empty XML element

-     //This constructor should be private, however std::make_shared() requires public access

-     //Therefore at least prevent users from calling it via private dummy type PrivateConstruction

-     template <class String>

-     XmlElement(const String& name, XmlElement* parentElement, PrivateConstruction) : name_(utfCvrtTo<std::string>(name)), parent_(parentElement) {}

-

-

-     template <class String>

-     String getNameAs() const { return utfCvrtTo<String>(name_); }

-

-

-     template <class T>

-     bool getValue(T& value) const { return readStruc(*this, value); }

-

-

-     template <class T>

-     void setValue(const T& value) { writeStruc(value, *this); }

-

-

-     template <class String, class T>

-     bool getAttribute(const String& name, T& value) const

-     {

-         auto it = attributes.find(utfCvrtTo<std::string>(name));

-         return it == attributes.end() ? false : readText(it->second, value);

-     }

-

-

-     template <class String, class T>

-     void setAttribute(const String& name, const T& value)

-     {

-         std::string attrValue;

-         writeText(value, attrValue);

-         attributes[utfCvrtTo<std::string>(name)] = attrValue;

-     }

-

-

-     template <class String>

-     void removeAttribute(const String& name) { attributes.erase(utfCvrtTo<std::string>(name)); }

-

-

-     template <class String>

-     XmlElement& addChild(const String& name)

-     {

-         std::string utf8Name = utfCvrtTo<std::string>(name);

-         auto newElement = std::make_shared<XmlElement>(utf8Name, this, PrivateConstruction());

-         childElements.push_back(newElement);

-         childElementsSorted.insert(std::make_pair(utf8Name, newElement));

-         return *newElement;

-     }

-

-

-     template <class String>

-     const XmlElement* getChild(const String& name) const

-     {

-         auto it = childElementsSorted.find(utfCvrtTo<std::string>(name));

-         return it == childElementsSorted.end() ? nullptr : &*(it->second);

-     }

-

-     template <class String>

-     XmlElement* getChild(const String& name)

-     {

-         return const_cast<XmlElement*>(static_cast<const XmlElement*>(this)->getChild(name));

-     }

-

-     template < class IterTy,     //underlying iterator type

-                class T,            //target object type

-                class AccessPolicy > //access policy: see AccessPtrMap

-     class PtrIter : public std::iterator<std::input_iterator_tag, T>, private AccessPolicy //get rid of shared_ptr indirection

-     {

-     public:

-         PtrIter(IterTy it) : it_(it) {}

-         PtrIter(const PtrIter& other) : it_(other.it_) {}

-         PtrIter& operator++() { ++it_; return *this; }

-         PtrIter operator++(int) { PtrIter tmp(*this); operator++(); return tmp; }

-         inline friend bool operator==(const PtrIter& lhs, const PtrIter& rhs) { return lhs.it_ == rhs.it_; }

-         inline friend bool operator!=(const PtrIter& lhs, const PtrIter& rhs) { return !(lhs == rhs); }

-         T& operator* () { return  AccessPolicy::template objectRef<T>(it_); }

-         T* operator->() { return &AccessPolicy::template objectRef<T>(it_); }

-     private:

-         IterTy it_;

-     };

-

-     struct AccessPtrMap

-     {

-         template <class T, class IterTy>

-         T& objectRef(const IterTy& it) { return *(it->second); }

-     };

-

-     typedef PtrIter<std::multimap<std::string, std::shared_ptr<XmlElement>>::iterator, XmlElement, AccessPtrMap> ChildIter2;

-     typedef PtrIter<std::multimap<std::string, std::shared_ptr<XmlElement>>::const_iterator, const XmlElement, AccessPtrMap> ChildIterConst2;

-

-

-     template <class String>

-     std::pair<ChildIterConst2, ChildIterConst2> getChildren(const String& name) const { return childElementsSorted.equal_range(utfCvrtTo<std::string>(name)); }

-

-     template <class String>

-     std::pair<ChildIter2, ChildIter2> getChildren(const String& name) { return childElementsSorted.equal_range(utfCvrtTo<std::string>(name)); }

-

-     struct AccessPtrVec

-     {

-         template <class T, class IterTy>

-         T& objectRef(const IterTy& it) { return **it; }

-     };

-

-     typedef PtrIter<std::vector<std::shared_ptr<XmlElement>>::iterator, XmlElement, AccessPtrVec> ChildIter;

-     typedef PtrIter<std::vector<std::shared_ptr<XmlElement>>::const_iterator, const XmlElement, AccessPtrVec> ChildIterConst;

-

-

-     std::pair<ChildIterConst, ChildIterConst> getChildren() const { return std::make_pair(childElements.begin(), childElements.end()); }

-

-     std::pair<ChildIter, ChildIter> getChildren() { return std::make_pair(childElements.begin(), childElements.end()); }

-

-     XmlElement* parent() { return parent_; };

-     const XmlElement* parent() const { return parent_; };

-

-

-     typedef std::map<std::string, std::string>::const_iterator AttrIter;

-

-     /* -> disabled documentation extraction

-       \brief Get all attributes associated with the element.

-       \code

-         auto iterPair = elem.getAttributes();

-         for (auto it = iterPair.first; it != iterPair.second; ++it)

-            std::cout << "name: " << it->first << " value: " << it->second << "\n";

-       \endcode

-       \return A pair of STL begin/end iterators to access all attributes sequentially as a list of name/value pairs of std::string.

-     */

-     std::pair<AttrIter, AttrIter> getAttributes() const { return std::make_pair(attributes.begin(), attributes.end()); }

-

-     //Transactionally swap two elements.  -> disabled documentation extraction

-     void swap(XmlElement& other)

-     {

-         name_     .swap(other.name_);

-         value_    .swap(other.value_);

-         attributes.swap(other.attributes);

-         childElements.swap(other.childElements);

-         childElementsSorted.swap(other.childElementsSorted);

-         //std::swap(parent_, other.parent_); -> parent is physical location; update children's parent reference instead:

-         std::for_each(      childElements.begin(),       childElements.end(), [&](const std::shared_ptr<XmlElement>& child) { child->parent_ = this;   });

-         std::for_each(other.childElements.begin(), other.childElements.end(), [&](const std::shared_ptr<XmlElement>& child) { child->parent_ = &other; });

-     }

-

- private:

-     friend class XmlDoc;

-

-     XmlElement(const XmlElement&);            //not implemented

-     XmlElement& operator=(const XmlElement&); //

-

-     std::string name_;

-     std::string value_;

-     std::map<std::string, std::string> attributes;

-     std::vector<std::shared_ptr<XmlElement>>                childElements;       //all child elements in order of creation

-     std::multimap<std::string, std::shared_ptr<XmlElement>> childElementsSorted; //alternate key: sorted by element name

-     XmlElement* parent_;

- };

-

-

- //XmlElement::setValue<T>() calls zen::writeStruc() which calls XmlElement::setValue() ... => these two specializations end the circle

- template <> inline

- void XmlElement::setValue(const std::string& value) { value_ = value; }

-

- template <> inline

- bool XmlElement::getValue(std::string& value) const { value = value_; return true; }

-

-

- class XmlDoc

- {

- public:

-     XmlDoc() : version_("1.0"), encoding_("UTF-8"), rootElement("Root", nullptr, XmlElement::PrivateConstruction()) {}

-

-     XmlDoc(XmlDoc&& tmp) : rootElement("Root", nullptr, XmlElement::PrivateConstruction()) { swap(tmp); }

-     XmlDoc& operator=(XmlDoc&& tmp) { swap(tmp); return *this; }

-

-     //Setup an empty XML document

-     template <class String>

-     XmlDoc(String rootName) : version_("1.0"), encoding_("UTF-8"), rootElement(rootName, nullptr, XmlElement::PrivateConstruction()) {}

-

-     const XmlElement& root() const { return rootElement; }

-     XmlElement& root() { return rootElement; }

-

-

-     template <class String>

-     String getVersionAs() const { return utfCvrtTo<String>(version_); }

-

-

-     template <class String>

-     void setVersion(const String& version) { version_ = utfCvrtTo<std::string>(version); }

-

-

-     template <class String>

-     String getEncodingAs() const { return utfCvrtTo<String>(encoding_); }

-

-

-     template <class String>

-     void setEncoding(const String& encoding) { encoding_ = utfCvrtTo<std::string>(encoding); }

-

-

-     template <class String>

-     String getStandaloneAs() const { return utfCvrtTo<String>(standalone_); }

-

-

-     template <class String>

-     void setStandalone(const String& standalone) { standalone_ = utfCvrtTo<std::string>(standalone); }

-

-     //Transactionally swap two elements.  -> disabled documentation extraction

-     void swap(XmlDoc& other)

-     {

-         version_   .swap(other.version_);

-         encoding_  .swap(other.encoding_);

-         standalone_.swap(other.standalone_);

-         rootElement.swap(other.rootElement);

-     }

-

- private:

-     XmlDoc(const XmlDoc&);            //not implemented, thanks to XmlElement::parent_

-     XmlDoc& operator=(const XmlDoc&); //

-

-     std::string version_;

-     std::string encoding_;

-     std::string standalone_;

-

-     XmlElement rootElement;

- };

-

- }

-

- #endif //ZEN_XML_DOM_HEADER_82085720723894567204564256

-zen::XmlDoc::root
const XmlElement & root() const
Get a const reference to the document's root element.
Definition: dom.h:267

-zen::XmlElement::parent
const XmlElement * parent() const
Get parent XML element, may be nullptr for root element.
Definition: dom.h:196

-zen::XmlElement::getValue
bool getValue(T &value) const
Get the value of this element as a user type.
Definition: dom.h:45

-zen::XmlElement::removeAttribute
void removeAttribute(const String &name)
Remove the attribute with the given name.
Definition: dom.h:89

-zen::XmlElement::getChildren
std::pair< ChildIterConst2, ChildIterConst2 > getChildren(const String &name) const
Access all child elements with the given name via STL iterators.
Definition: dom.h:164

-zen::XmlDoc::setEncoding
void setEncoding(const String &encoding)
Set the encoding used in the XML declaration.
Definition: dom.h:297

-zen::XmlElement::getChildren
std::pair< ChildIterConst, ChildIterConst > getChildren() const
Access all child elements sequentially via STL iterators.
Definition: dom.h:188

-zen::readText
bool readText(const std::string &input, T &value)
Convert text to user data - used by XML elements and attributes.
Definition: cvrt_text.h:216

-zen::XmlElement
An XML element.
Definition: dom.h:21

-zen::XmlDoc::XmlDoc
XmlDoc(String rootName)
Definition: dom.h:264

-zen::XmlElement::getChildren
std::pair< ChildIter, ChildIter > getChildren()
Definition: dom.h:191

-zen::XmlElement::getChild
XmlElement * getChild(const String &name)
Definition: dom.h:121

-zen::XmlElement::getAttribute
bool getAttribute(const String &name, T &value) const
Retrieve an attribute by name.
Definition: dom.h:63

-zen::XmlDoc::setVersion
void setVersion(const String &version)
Set the version used in the XML declaration.
Definition: dom.h:283

-zen::XmlDoc::setStandalone
void setStandalone(const String &standalone)
Set the standalone string used in the XML declaration.
Definition: dom.h:311

-zen::XmlDoc
The complete XML document.
Definition: dom.h:249

-zen::XmlDoc::XmlDoc
XmlDoc()
Default constructor setting up an empty XML document with a standard declaration: <...
Definition: dom.h:253

-zen::XmlDoc::getEncodingAs
String getEncodingAs() const
Get the encoding used in the XML declaration.
Definition: dom.h:290

-zen::XmlElement::addChild
XmlElement & addChild(const String &name)
Create a new child element and return a reference to it.
Definition: dom.h:97

-zen::XmlDoc::root
XmlElement & root()
Get a reference to the document's root element.
Definition: dom.h:269

-zen::XmlElement::getChild
const XmlElement * getChild(const String &name) const
Retrieve a child element with the given name.
Definition: dom.h:113

-zen::readStruc
bool readStruc(const XmlElement &input, T &value)
Convert XML element to structured user data.
Definition: cvrt_struc.h:205

-zen::XmlElement::parent
XmlElement * parent()
Get parent XML element, may be nullptr for root element.
Definition: dom.h:194

-zen::XmlElement::setValue
void setValue(const T &value)
Set the value of this element.
Definition: dom.h:52

-zen::XmlDoc::getVersionAs
String getVersionAs() const
Get the version used in the XML declaration.
Definition: dom.h:276

-zen::XmlElement::setAttribute
void setAttribute(const String &name, const T &value)
Create or update an XML attribute.
Definition: dom.h:77

-zen::writeStruc
void writeStruc(const T &value, XmlElement &output)
Convert structured user data into an XML element.
Definition: cvrt_struc.h:198

-zen::XmlElement::getChildren
std::pair< ChildIter2, ChildIter2 > getChildren(const String &name)
Definition: dom.h:168

-zen::XmlDoc::getStandaloneAs
String getStandaloneAs() const
Get the standalone string used in the XML declaration.
Definition: dom.h:304

-zen::XmlElement::getNameAs
String getNameAs() const
Retrieve the name of this XML element.
Definition: dom.h:37

-zen::writeText
void writeText(const T &value, std::string &output)
Convert user data into text - used by XML elements and attributes.
Definition: cvrt_text.h:209

-