/** * @file include/ActivMiddleware/ActivBase/XmlParser.h * * @brief Header file for XmlParser. */ #if (!defined ACTIV_BASE_XML_PARSER_H) #define ACTIV_BASE_XML_PARSER_H #include "ActivMiddleware/ActivBase/External.h" #include "ActivMiddleware/ActivBase/MessageValidator.h" #include "ActivMiddleware/CxxYZ/functional.h" #include "ActivMiddleware/CxxYZ/memory.h" #include "ActivMiddleware/CxxYZ/string_view.h" #include ACTIV_BOOST_INCLUDE(exception/all.hpp) namespace Activ { namespace TinyXml { struct pImplDoc; struct pImplAttr; struct pImplNode; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- //! XML parser class. class XmlParser { public: typedef TinyXml::pImplAttr BaseXmlAttr; typedef TinyXml::pImplNode BaseXmlNode; typedef TinyXml::pImplDoc BaseXmlDoc; typedef char BaseXmlChar; #if (defined ACTIV_COMPILER_VISUAL_C) typedef LengthToIntegralType::Type ssize_t; #endif //! Exception thrown on parsing and validation errors. class Exception : public virtual Boost::exception, public virtual std::exception { public: typedef Boost::error_info NameInfo; typedef Boost::error_info NodeInfo; typedef Boost::error_info AttributeInfo; typedef Boost::error_info ValueInfo; typedef Boost::error_info ErrorInfo; typedef Boost::error_info LineInfo; // std::exception overrides. ACTIV_BASE_API virtual const char *what() const throw() ACTIV_OVERRIDE; }; class Children; class Attributes; //! Node. class Node { public: //! Get the name of the node. ACTIV_BASE_API String GetName() const; //! Get children of the node. ACTIV_BASE_API Children GetChildren() const; // Is a node NODE_TYPE_ELEMENT? ACTIV_BASE_API bool IsElement() const; //! Get the value of the node. ACTIV_BASE_API String GetValue() const; //! Get text. ACTIV_BASE_API String GetText() const; //! Get a range of attributes for the node. ACTIV_BASE_API Attributes GetAttributes() const; /** * @brief Get an attribute string by name. * * @tparam MANDATORY whether to throw if the attribute is not found. * @param attributeName * @param value to receive the attribute's value. * * @retval true if attribute was found. * @retval false if MANDATORY was false and the attribute was not found. * @throw Exception MANDATORY was true and the attribute was not found. */ template bool GetAttribute(const String &attributeName, String &value) const; /** * @brief Get a boolean attribute by name. * * @tparam MANDATORY whether to throw if the attribute is not found. * @param attributeName * @param value to receive the attribute's value. * * @retval true if attribute was found. * @retval false if MANDATORY was false and the attribute was not found. * @throw Exception MANDATORY was true and the attribute was not found. */ template bool GetAttribute(const String &attributeName, bool &value) const; /** * @brief Get an unsigned integral attribute by name. * * @tparam MANDATORY whether to throw if the attribute is not found. * @param attributeName * @param value to receive the attribute's value. * * @retval true if attribute was found. * @retval false if MANDATORY was false and the attribute was not found. * @throw Exception MANDATORY was true and the attribute was not found, or the attributes contents were not * an unsigned integral. */ template typename Boost::enable_if_c::value && Boost::is_unsigned::value, bool>::type GetAttribute(const String &attributeName, T &value) const { // vc100 gets upset if this is out-of-line. String str; if (!GetAttribute(attributeName, str)) return false; MessageValidator messageValidator(str.c_str(), str.length()); if (STATUS_CODE_SUCCESS != messageValidator.ValidateUnsignedAsciiIntegral(messageValidator.GetLength(), value)) { Exception exception(MakeException(attributeName, "invalid format")); exception << Exception::ValueInfo(str); ACTIV_BOOST_THROW_EXCEPTION(exception); } return true; } /** * @brief Get a mandatory attribute by name. * * @param attributeName * * @retval true if attribute was found. * @retval false if MANDATORY was false and the attribute was not found. * @throw Exception MANDATORY was true and the attribute was not found, or the attributes contents were not * an unsigned integral. */ template T GetAttribute(const String &attributeName) const { T value; (void) GetAttribute(attributeName, value); return value; } /** * @brief Get an attribute's value by name and apply a conversion function. * * @tparam MANDATORY whether to throw if the attribute is not found. * @param attributeName * @param convertFunction the function to apply. It must take const String & and return T. * @param value to receive the attribute's value. * * @retval true if attribute was found. * @retval false if MANDATORY was false and the attribute was not found. * @throw Exception MANDATORY was true and the attribute was not found. The conversion function may throw other types. */ template bool GetAttribute(const String &attributeName, const F &convertFunction, T &value) const; private: ACTIV_BASE_API bool GetMandatoryStringAttribute(const String &attributeName, String &value) const; ACTIV_BASE_API bool GetOptionalStringAttribute(const String &attributeName, String &value) const; template bool GetBooleanAttribute(const String &attributeName, bool &value) const; ACTIV_BASE_API Exception MakeException(const String &attributeName, const String &reason) const; ACTIV_BASE_API Node(BaseXmlNode * pNode); BaseXmlNode * m_pNode; friend class XmlParser; }; //! Attribute node. class Attribute { public: //! Get the name of the node. ACTIV_BASE_API String GetName() const; //! Get the attribute's value. ACTIV_BASE_API String GetValue() const; private: ACTIV_BASE_API Attribute(BaseXmlAttr * pAttr); BaseXmlAttr * m_pAttr; friend class XmlParser; }; //! Simple helper to provide begin/end range for child nodes. class Children { public: /** * @brief Iterator class. */ class Iterator : public std::iterator { public: //! Default constructor. Iterator(); //! Pre-increment operator. ACTIV_BASE_API Iterator &operator++(); //! Post-increment operator. Iterator operator++(int); //! Pre-decrement operator. ACTIV_BASE_API Iterator &operator--(); //! Post-decrement operator. Iterator operator--(int); //! Equality operator. bool operator==(const Iterator &rhs) const; //! Inequality operator. bool operator!=(const Iterator &rhs) const; //! Deference operator. const Node &operator*() const; //! Deference operator. Node &operator*(); //! Indirection operator. const Node *operator->() const; private: Iterator(BaseXmlNode * const m_pParentNode, BaseXmlNode * const m_pNode); BaseXmlNode * m_pParentNode; Node m_node; friend class XmlParser; }; typedef Iterator const_iterator; //! begin() const_iterator. ACTIV_BASE_API const_iterator begin() const; //! end() const_iterator. ACTIV_BASE_API const_iterator end() const; //! Is the range empty? bool empty() const; private: Children(BaseXmlNode * pNode); BaseXmlNode * m_pNode; friend class Node; }; // Simple helper to provide begin/end range for attribute nodes. class Attributes { public: /** * @brief Iterator class. */ class Iterator : public std::iterator { public: //! Default constructor. Iterator(); //! Pre-increment operator. ACTIV_BASE_API Iterator &operator++(); //! Post-increment operator. Iterator operator++(int); //! Equality operator. bool operator==(const Iterator &rhs) const; //! Inequality operator. bool operator!=(const Iterator &rhs) const; //! Deference operator. const Attribute &operator*() const; //! Deference operator. Attribute &operator*(); //! Indirection operator. const Attribute *operator->() const; private: Iterator(BaseXmlAttr * pAttr); Attribute m_attribute; friend class XmlParser; }; //! Attribute node const_iterator type. typedef Iterator const_iterator; //! Destructor. ACTIV_BASE_API ~Attributes(); //! begin() const_iterator. const_iterator begin() const; //! end() const_iterator. const_iterator end() const; //! Is the range empty? bool empty() const; private: Attributes(BaseXmlAttr * pAttrs); BaseXmlAttr * m_pAttrs; friend class Node; }; /** * @brief Constructor to parse an XML file. * * @param fileName * * @throw Exception */ ACTIV_BASE_API XmlParser(const String &fileName); /** * @brief Constructor to parse an XML string. * * @param name * @param xmlString * * @throw Exception */ ACTIV_BASE_API XmlParser(const String &name, const CxxYZ::string_view &xmlString); //! Get the root node. ACTIV_BASE_API Node GetRoot() const; private: class Document { public: ACTIV_BASE_API Document(const String &fileName); ACTIV_BASE_API Document(const String &name, const CxxYZ::string_view &xmlString); ACTIV_BASE_API ~Document(); Exception MakeException() const; CxxYZ::unique_ptr m_pDocument; }; class XmlString { public: XmlString(); XmlString(const BaseXmlChar * const pStr); ~XmlString(); const BaseXmlChar * const m_pStr; }; Document m_document; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- template inline bool XmlParser::Node::GetAttribute(const String &attributeName, String &value) const { if (MANDATORY) return GetMandatoryStringAttribute(attributeName, value); else return GetOptionalStringAttribute(attributeName, value); } // --------------------------------------------------------------------------------------------------------------------------------- template inline bool XmlParser::Node::GetAttribute(const String &attributeName, bool &value) const { return GetBooleanAttribute(attributeName, value); } // --------------------------------------------------------------------------------------------------------------------------------- template bool XmlParser::Node::GetAttribute(const String &attributeName, const F &convertFunction, T &value) const { String str; if (!GetAttribute(attributeName, str)) return false; value = convertFunction(str); return true; } // --------------------------------------------------------------------------------------------------------------------------------- template inline bool XmlParser::Node::GetBooleanAttribute(const String &attributeName, bool &value) const { String str; if (!GetAttribute(attributeName, str)) return false; value = (0 == ::stricmp(str.c_str(), "true")); return true; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Children::empty() const { return (begin() == end()); } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Children::Children(BaseXmlNode * pNode) : m_pNode(pNode) { } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Children::Iterator::Iterator() : m_pParentNode(ACTIV_NULLPTR), m_node(ACTIV_NULLPTR) { } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Children::Iterator XmlParser::Children::Iterator::operator++(int) { Iterator initialValue(*this); this->operator++(); return initialValue; } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Children::Iterator XmlParser::Children::Iterator::operator--(int) { Iterator initialValue(*this); this->operator--(); return initialValue; } // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Children::Iterator::operator==(const XmlParser::Children::Iterator &rhs) const { return (m_node.m_pNode == rhs.m_node.m_pNode); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Children::Iterator::operator!=(const XmlParser::Children::Iterator &rhs) const { return !(*this == rhs); } // --------------------------------------------------------------------------------------------------------------------------------- inline const XmlParser::Node &XmlParser::Children::Iterator::operator*() const { return m_node; } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Node &XmlParser::Children::Iterator::operator*() { return m_node; } // --------------------------------------------------------------------------------------------------------------------------------- inline const XmlParser::Node *XmlParser::Children::Iterator::operator->() const { return &m_node; } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Children::Iterator::Iterator(BaseXmlNode * const m_pParentNode, XmlParser::BaseXmlNode * const pNode) : m_pParentNode(m_pParentNode), m_node(pNode) { } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::Iterator::Iterator() : m_attribute(ACTIV_NULLPTR) { } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::Iterator XmlParser::Attributes::Iterator::operator++(int) { Iterator initialValue(*this); this->operator++(); return initialValue; } // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Attributes::Iterator::operator==(const XmlParser::Attributes::Iterator &rhs) const { return (m_attribute.m_pAttr == rhs.m_attribute.m_pAttr); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Attributes::Iterator::operator!=(const XmlParser::Attributes::Iterator &rhs) const { return !(*this == rhs); } // --------------------------------------------------------------------------------------------------------------------------------- inline const XmlParser::Attribute &XmlParser::Attributes::Iterator::operator*() const { return m_attribute; } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attribute &XmlParser::Attributes::Iterator::operator*() { return m_attribute; } // --------------------------------------------------------------------------------------------------------------------------------- inline const XmlParser::Attribute *XmlParser::Attributes::Iterator::operator->() const { return &m_attribute; } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::Iterator::Iterator(XmlParser::BaseXmlAttr * pAttr) : m_attribute(pAttr) { } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::const_iterator XmlParser::Attributes::begin() const { return const_iterator(m_pAttrs); } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::const_iterator XmlParser::Attributes::end() const { return const_iterator(ACTIV_NULLPTR); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool XmlParser::Attributes::empty() const { return (begin() == end()); } // --------------------------------------------------------------------------------------------------------------------------------- inline XmlParser::Attributes::Attributes(BaseXmlAttr * pAttrs) : m_pAttrs(pAttrs) { } } // namespace Activ // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- namespace ACTIV_BOOST_NAMESPACE { // For BOOST_FOREACH support, mainly. template<> struct range_const_iterator { typedef Activ::XmlParser::Children::const_iterator type; }; template<> struct range_mutable_iterator { // There is no mutable iterator; use const. typedef Activ::XmlParser::Children::const_iterator type; }; // --------------------------------------------------------------------------------------------------------------------------------- template<> struct range_const_iterator { typedef Activ::XmlParser::Attributes::const_iterator type; }; template<> struct range_mutable_iterator { // There is no mutable iterator; use const. typedef Activ::XmlParser::Attributes::const_iterator type; }; // --------------------------------------------------------------------------------------------------------------------------------- namespace iterators { template<> struct iterator_reference { typedef const Activ::XmlParser::Node &type; }; template<> struct iterator_reference { typedef const Activ::XmlParser::Attribute &type; }; } // namespace iterators } // namespace ACTIV_BOOST_NAMESPACE #endif // (!defined ACTIV_BASE_XML_PARSER_H)