XMLNode.h

Go to the documentation of this file.

#ifndef XML_NODE_H_
#define XML_NODE_H_
 
#include <memory>
#include <sstream>
#include <string>
#include <unordered_set>
#include <vector>
 
// Tell TinyXML to use the stl.
#ifndef TIXML_USE_STL
#define TIXML_USE_STL
#endif
 
#include "tinyxml2.h"
 
#include "PMPLExceptions.h"
 
 
class XMLNode {
 
  public:
 
 
    XMLNode(const std::string& _filename, const std::string& _desiredNode);
 
    XMLNode(const std::string& _filename, std::shared_ptr<tinyxml2::XMLDocument> doc, const std::string& _desiredNode);
 
  private:
 
    XMLNode(tinyxml2::XMLNode* _node, const std::string& _filename,
        std::shared_ptr<tinyxml2::XMLDocument> _doc);
 
 
  void FindNode(const std::string& _desiredNode);
 
  public:
 
 
    typedef std::vector<XMLNode>::iterator iterator;
 
    iterator begin();
 
    iterator end();
 
 
    const std::string& Name() const;
 
    const std::string& Filename() const;
 
    std::string GetPath() const;
 
 
    std::string GetText() const;
 
 
    template <typename T>
    T Read(const std::string& _name, const bool _req, const T& _default,
        const T& _min, const T& _max, const std::string& _desc);
 
    bool Read(const std::string& _name, const bool _req, const bool _default,
        const std::string& _desc);
 
    std::string Read(const std::string& _name, const bool _req,
        const char* _default, const std::string& _desc);
 
    std::string Read(const std::string& _name,
        const bool _req,
        const std::string& _default,
        const std::string& _desc);
 
 
    void Ignore();
 
    void WarnAll(const bool _warningsAsErrors = false);
 
    std::string Where() const;
 
 
  private:
 
 
    std::string Where(const std::string& _f, const int _l, const int _c,
        const bool _name = true) const;
 
    void BuildChildVector();
 
    std::string AttrWrongType(const std::string& _name, const std::string& _desc)
        const;
 
    std::string AttrMissing(const std::string& _name, const std::string& _desc)
        const;
 
    template <typename T>
    std::string AttrInvalidBounds(const std::string& _name,
        const std::string& _desc, const T& _min, const T& _max, const T& _val)
        const;
 
    void ComputeAccessed();
 
    void WarnAllRec(bool& _anyWarnings);
 
    void WarnUnknownNode();
 
    bool WarnUnrequestedAttributes();
 
 
    tinyxml2::XMLNode* m_node{nullptr};      
    bool m_childBuilt{false};        
    bool m_accessed{false};          
    std::vector<XMLNode> m_children; 
    std::unordered_set<std::string> m_reqAttributes; 
    std::string m_filename;          
 
    std::shared_ptr<tinyxml2::XMLDocument> m_doc;
 
};
 
// specialization for size_t since tinyxml2 doesn't support it
template <>
size_t 
XMLNode::
Read(const std::string& _name, const bool _req, const size_t& _default,
    const size_t& _min, const size_t& _max, const std::string& _desc);
 
/*---------------------------- Templated Members -----------------------------*/
 
template <typename T>
T
XMLNode::
Read(const std::string& _name, const bool _req, const T& _default, const T& _min,
    const T& _max, const std::string& _desc) {
  m_accessed = true;
  m_reqAttributes.insert(_name);
  T toReturn;
 
  tinyxml2::XMLError qr = m_node->ToElement()->QueryAttribute(_name.c_str(), &toReturn);
  switch(qr) {
    case tinyxml2::XML_WRONG_ATTRIBUTE_TYPE:
      throw ParseException(Where(), AttrWrongType(_name, _desc));
      break;
    case tinyxml2::XML_NO_ATTRIBUTE:
      {
        if(_req)
          throw ParseException(Where(), AttrMissing(_name, _desc));
        else
          toReturn = _default;
        break;
      }
    case tinyxml2::XML_SUCCESS:
      {
        if(toReturn < _min || toReturn > _max)
          throw ParseException(Where(),
              AttrInvalidBounds(_name, _desc, _min, _max, toReturn));
        break;
      }
    default:
      throw RunTimeException(WHERE, "Logic shouldn't be able to reach this.");
  }
 
  return toReturn;
}
 
 
template <typename T>
std::string
XMLNode::
AttrInvalidBounds(const std::string& _name, const std::string& _desc,
    const T& _min, const T& _max, const T& _val) const {
  std::ostringstream oss;
  oss << "Invalid value for attribute '" << _name << "'."
      << "\n\tAttribute description: " << _desc << "."
      << "\n\tValid range: [" << _min << ", " << _max << "]"
      << "\n\tValue specified: " << _val;
  return oss.str();
}
 
/*----------------------------------------------------------------------------*/
 
#endif