XmlParser.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _GranOO_LibUtil_XmlParser_H
#define _GranOO_LibUtil_XmlParser_H
 
 
#include <map>
#include <vector>
#include <algorithm>
#include <array>
#include <regex>
 
 
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
 
#include "GranOO3/Core/TinyXml.hpp"
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Core/String.hpp"
#include "GranOO3/Core/Out.hpp"
 
 
// This macro assert a condition while reading an xml file
// and print a friendly error message
#define XmlAssert(condition, message) \
  GranOO3::Core::XmlParser::get().raise_assertion(!(condition), __LINE__,  __FILE__, #condition, message);
 
namespace GranOO3
{
  namespace Core
  {
    template<class T> class SetOf;
  }
  namespace Geom
  {
    class Vector;
    class Point;
    class Quaternion;
    class Frame;
  }
  namespace Math
  {
    class Expression;
  }
}
 
 
 
 
namespace GranOO3
{
  namespace Core
  {
 
    template<typename T>
    class XmlObjectManager
    {
    public:
      static void read_xml_file(const std::string & xPathParent, const std::string & filename = Core::String::empty_string);
      static T* read_element(const TiXmlElement*, bool ID_required = true);
      static T* get_item(const std::string &);
      static T& get(const std::string &);
      static bool exist(const std::string &);
      static std::string get_ID (const T*);
      static void add_item(const std::string &,  T *);
      static std::string class_ID() {return std::string("XmlObjectManager<"+std::string(typeid(T).name())+">");}
      static void clear();
      static void erase_item(const T*);
      static std::vector<std::string> get_ID();
      static std::string get_list();
 
    private:
      static std::map<const std::string, T *> map_;
 
    private:
      XmlObjectManager();
      XmlObjectManager(const XmlObjectManager&);
      XmlObjectManager& operator=(const XmlObjectManager&);
      ~XmlObjectManager();
    };
 
 
 
 
    //
    // Class XmlParser is a singleton. Is gives methodes
    // to open, parse and read an XML tree
    //
    enum State {GRANOO_REQUIRED=0, GRANOO_OPTIONAL=1, GRANOO_UNIQUE=2};
 
    namespace Attribute {enum State {GRANOO_REQUIRED=0, GRANOO_OPTIONAL=1};}
    namespace Element {  enum State {GRANOO_REQUIRED=0, GRANOO_OPTIONAL=1, GRANOO_UNIQUE=2};}
 
    class XmlParser
    {
    public:
      static XmlParser& get();
 
      // Internal use only, not documented
      static XmlParser& open(const std::string&);
      static XmlParser& open_memory(const std::string&, const std::string&);
 
    public:
      // Internal use only, not documented
      TiXmlDocument& get_xml_doc();
      const TiXmlDocument& get_xml_doc() const;
 
      const TiXmlElement* get_root_element(const std::string&);
      const TiXmlElement* get_root_element();
      const TiXmlElement* get_child_element(const Element::State, const TiXmlNode*, const std::string&);
      const TiXmlElement* get_child_element(const Element::State, const TiXmlNode*);
 
 
      void set_current_element(const TiXmlElement*);
      const TiXmlElement* get_current_element();
 
      void check_unread_attribute();
      void check_unread_element();
 
 
      bool attribute_exist(const std::string&);
 
 
 
      template<typename T> // T must be a container
      void check_allowed_element_name(const T&);
 
      template<typename T> // T must be a container
      void check_unique_child_with_allowed_element_name(const T&);
 
      void raise_assertion(bool, int, const std::string&, const std::string&, const std::string&);
 
      // Only these methods are documented
      template<typename T> void read_attribute(const Attribute::State, const std::string&, T&);
      template<typename T> T    read_attribute(const Attribute::State, const std::string&);
      template<typename T> T read_attribute(const std::string&, T);    // Optional state with given default value
 
      template<typename T> void CheckAllowedAttributeValue(const std::string& name, const T&); // T must be an array
 
 
      template <typename ... T>
      void AllowedValue(const std::string& name, const T& ...);
      template<typename T>
      void AllowedValue(const std::string& name, const T&);
      template<typename T>
      void AllowedValue(const std::string& name, const T&, const T&);
      template<typename T>
      void AllowedValue(const std::string& name, const T&, const T&, const T&);
      template<typename T>
      void AllowedValue(const std::string& name, const T&, const T&, const T&, const T&);
      template<typename T>
      void AllowedValue(const std::string& name, const T&, const T&, const T&, const T&, const T&);
      template<typename T>
      void AllowedValue(const std::string& name, const T&, const T&, const T&, const T&, const T&, const T&);
 
      void check_attribute_in_conflict(const std::string&, const std::string&);
      std::string  ErrorMsg(const std::string) const;
 
    private:
      XmlParser(); // Not implemented
      XmlParser(const std::string&);
      XmlParser(const std::string&, const std::string&);
      virtual ~XmlParser();
 
      std::string RawText(const TiXmlNode*, const unsigned int maxLength = 0) const;
 
      void check_unread_attribute(const TiXmlElement*);
      void check_attribute_in_conflict(const TiXmlElement*, const std::string&, const std::string&);
 
      const TiXmlElement* get_child_element_required(const TiXmlNode*, const std::string&);
      const TiXmlElement* get_child_element_optional(const TiXmlNode*, const std::string&);
      const TiXmlElement* get_child_element_unique  (const TiXmlNode*, const std::string&);
      const TiXmlElement* get_child_element_required(const TiXmlNode*);
      const TiXmlElement* get_child_element_optional(const TiXmlNode*);
      const TiXmlElement* get_child_element_unique  (const TiXmlNode*);
 
      template<typename T> void read_attribute(const Attribute::State, const TiXmlElement*, const std::string&, T&);
      template<typename T> T    read_attribute(const Attribute::State, const TiXmlElement*, const std::string&);
      template<typename T> T read_attribute(const TiXmlElement*, const std::string&, T);    // Optional state with given default value
 
 
      template<typename T> void set_valueFromAttribute(const TiXmlElement*, const std::string&, T&, Attribute::State);
      template<typename T> void set_valueFromAttribute_Optional(const TiXmlElement*, const std::string&, T&);
      template<typename T> void set_valueFromAttribute_Required(const TiXmlElement*, const std::string&, T&);
 
 
      template<typename T> T get_AttributeValue(const TiXmlElement*, const std::string&, Attribute::State, T = T());
      template<typename T> T get_AttributeValue_Optional(const TiXmlElement*, const std::string&, T = T());
      template<typename T> T get_AttributeValue_Required(const TiXmlElement*, const std::string&);
 
      template<typename T> void ConvertStringTo(const TiXmlElement*, const std::string&, T&);
      template<typename T> void ConvertStringTo(const TiXmlElement*, const std::string&, std::vector<T>&);
      template<typename T> void ConvertStringTo(const TiXmlElement*, const std::string&, Core::SetOf<T>*&);
      template<typename T> std::string TypeName();
 
 
      void AddAllowedAttributeName(const TiXmlElement*, const std::string&);
      const std::vector<std::string>& get_allowedAttributeNamelist(const TiXmlElement*);
 
      bool attribute_exist(const TiXmlElement*, const std::string&);
 
      std::string  ErrorMsg(const TiXmlNode*, const std::string) const;
 
      std::string  ErrorMsg() const;
      void raise_assertion(const TiXmlElement*, const int, const std::string&, const std::string&, const std::string&);
 
      bool has_been_read(const TiXmlElement*) const;
      void get_all_document_element_recursive(const TiXmlElement*, std::vector<const TiXmlElement*>&) const;
      std::vector<const TiXmlElement*> get_all_document_element() const;
 
    private:
      static XmlParser* _me;
 
    private:
      const std::string _doc_name;
      TiXmlDocument _doc;
      std::map<const TiXmlElement*, std::vector<std::string> > _allowed_attribute_name;
      std::vector<const TiXmlElement*> _element_read;
      const TiXmlElement*              _root_element;
      const TiXmlElement*              _current_element;
    };
 
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    template<typename T>
    void
    XmlParser::read_attribute(const Attribute::State state,  const std::string& name, T& val) {
      read_attribute(state, get_current_element(), name, val);
    }
 
    template<typename T>
    T
    XmlParser::read_attribute(const Attribute::State state, const std::string& name) {
      return read_attribute<T>(state, get_current_element(), name);
    }
 
    template<typename T>
    T
    XmlParser::read_attribute(const std::string& name, T defaultVal) {
      return read_attribute<T>(get_current_element(), name, defaultVal);
    }
 
    template<typename T>
    void
    XmlParser::read_attribute(const Attribute::State state, const TiXmlElement* el, const std::string& name, T& val) {
      AddAllowedAttributeName(el, name);
      set_valueFromAttribute(el, name, val, state);
    }
 
    template<typename T>
    T
    XmlParser::read_attribute(const Attribute::State state, const TiXmlElement* el, const std::string& name) {
      if constexpr (std::is_same<T, Geom::Vector>::value) {
    T val = Geom::Vector(0.,0, 0.);
    AddAllowedAttributeName(el, name);
    return get_AttributeValue(el, name, state, val);
      }
 
      if constexpr (std::is_same<T, Geom::Point>::value) {
    T val = Geom::Point(0.,0, 0.);
    AddAllowedAttributeName(el, name);
    return get_AttributeValue(el, name, state, val);
      }
 
      if constexpr (std::is_same<T, Geom::Quaternion>::value) {
    T val = Geom::Quaternion(0.,0, 0.,0.);
    AddAllowedAttributeName(el, name);
    return get_AttributeValue(el, name, state, val);
      }
      
      T val = T();
      AddAllowedAttributeName(el, name);
      return get_AttributeValue(el, name, state, val);
    }
 
    template<typename T>
    T
    XmlParser::read_attribute(const TiXmlElement* el, const std::string& name, T defaultVal) {
      AddAllowedAttributeName(el, name);
      set_valueFromAttribute_Optional(el, name, defaultVal);
      return defaultVal;
    }
 
    template<typename T>
    void
    XmlParser::set_valueFromAttribute(const TiXmlElement* el, const std::string& name, T& val, Attribute::State state) {
      switch (state) {
      case Attribute::GRANOO_REQUIRED:
      {
        set_valueFromAttribute_Required<T>(el, name, val);
        break;
      }
      case Attribute::GRANOO_OPTIONAL:
      {
        set_valueFromAttribute_Optional<T>(el, name, val);
        break;
      }
      default:
      {
        InternAssert(0);
      }
      }
    }
 
    template<typename T>
    void
    XmlParser::set_valueFromAttribute_Optional(const TiXmlElement* el, const std::string& name, T& val) {
      val = get_AttributeValue_Optional<T>(el, name, val);
    }
 
    template<typename T> void
    XmlParser::set_valueFromAttribute_Required(const TiXmlElement* el, const std::string& name, T& val) {
      val = get_AttributeValue_Required<T>(el, name);
    }
 
    template<typename T>
    T
    XmlParser::get_AttributeValue(const TiXmlElement* el, const std::string& name, Attribute::State state, T val) {
      switch (state) {
      case Attribute::GRANOO_REQUIRED:
      {
        return get_AttributeValue_Required<T>(el, name);
        break;
      }
      case Attribute::GRANOO_OPTIONAL:
      {
        return get_AttributeValue_Optional<T>(el, name, val);
        break;
      }
      default:
      {
        InternAssert(0);
      }
      }
      InternAssert(0);
      return val;
    }
 
    template<typename T>
    T
    XmlParser::get_AttributeValue_Optional(const TiXmlElement *el, const std::string & name, T val) {
      if (attribute_exist(el, name))
        ConvertStringTo(el, el->Attribute(name.c_str()), val);
      return val;
    }
 
    template<typename T>
    T
    XmlParser::get_AttributeValue_Required(const TiXmlElement *el, const std::string & name) {
      std::string errMsg = "Cannot find the required attribute " + String::quote(name);
      AssertMsg(attribute_exist(el, name), ErrorMsg(el, errMsg));
 
      T val = T();
      ConvertStringTo(el, el->Attribute(name.c_str()), val);
      return val;
    }
 
    template <typename ... T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& ... args) {
      std::array<std::string, sizeof...(args)> val{{args ...}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v) {
      std::array<T, 1> val = {{v}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v1, const T& v2) {
      std::array<T, 2> val = {{v1, v2}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v1, const T& v2, const T& v3) {
      std::array<T, 3> val = {{v1, v2, v3}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v1, const T& v2, const T& v3, const T& v4) {
      std::array<T, 4> val = {{v1, v2, v3, v4}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) {
      std::array<T, 5> val = {{v1, v2, v3, v4, v5}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::AllowedValue(const std::string& name, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6) {
      std::array<T, 6> val = {{v1, v2, v3, v4, v5, v6}};
      CheckAllowedAttributeValue(name, val);
    }
 
    template<typename T>
    void
    XmlParser::CheckAllowedAttributeValue(const std::string& name, const T& array) {
      const TiXmlElement* el = get_current_element();
      if (attribute_exist(el, name) == false)
        return;
 
      const typename T::value_type val = get_AttributeValue_Required<typename T::value_type>(el, name);
      bool find = false;
      std::ostringstream allowedVal;
 
      for (typename T::const_iterator it = array.begin(); it!=array.end(); ++it) {
        allowedVal << "'" << *it << "'";
        if (val == *it)
          find = true;
 
        if (array.size() > 1) {
          if (it < array.end()-2)
            allowedVal <<  ", ";
          else if (it == array.end()-2)
            allowedVal << " or ";
        }
 
      }
 
      std::ostringstream errMsg;
      errMsg << "The attribute " << String::quote(name)
             << " must take the followed values : " << allowedVal.str();
      AssertMsg(find == true, ErrorMsg(el, errMsg.str()));
    }
 
    template<typename T>
    void
    XmlParser::check_allowed_element_name(const T& array) {
      const TiXmlElement* el = get_current_element();
 
      const std::string val = el->Value();
      bool find = false;
      std::ostringstream allowedVal;
 
      for (typename T::const_iterator it = array.begin(); it!=array.end(); ++it) {
        allowedVal << "'" << *it << "'";
        if (val == *it)
          find = true;
 
        if (array.size() > 1) {
          if (it < array.end()-2)
            allowedVal <<  ", ";
          else if (it == array.end()-2)
            allowedVal << " or ";
        }
 
      }
 
      std::ostringstream errMsg;
      errMsg << "The name of the current element  must be : " << allowedVal.str();
      AssertMsg(find == true, ErrorMsg(el, errMsg.str()));
    }
 
    template<typename T>
    void
    XmlParser::check_unique_child_with_allowed_element_name(const T& array) {
      const TiXmlElement* el = get_current_element();
 
      const std::string val = get_child_element_required(el)->Value();
      bool find = false;
      std::ostringstream allowedVal;
 
      for (typename T::const_iterator it = array.begin(); it!=array.end(); ++it) {
        allowedVal << "'" << *it << "'";
        if (val == *it)
          find = true;
 
        if (array.size() > 1) {
          if (it < array.end()-2)
            allowedVal <<  ", ";
          else if (it == array.end()-2)
            allowedVal << " or ";
        }
 
      }
 
      std::ostringstream errMsg;
      errMsg << "This element must have a unique child. This child must be : " << allowedVal.str();
      AssertMsg(find == true, ErrorMsg(el, errMsg.str()));
    }
 
    template<typename T>
    void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, T& val) {
      try {
        val = boost::lexical_cast<T>(str);
      }
      catch (const boost::bad_lexical_cast&) {
        std::string errMsg = "Cannot convert the characters \"" +  str + "\" to type " + String::quote(TypeName<T>());
        AssertMsg(0, ErrorMsg(el, errMsg));
      }
    }
 
    template<typename T>
    void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, std::vector<T>& val) {
      val.clear();
      std::vector<std::string> strList;
      boost::split(strList, str, boost::is_any_of(Core::String::sep));
      val.resize(strList.size());
      for (unsigned int i = 0; i < strList.size(); ++i) {
        ConvertStringTo(el, strList[i], val[i]);
      }
    }
 
    template<typename T>
    void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Core::SetOf<T>*& val) {
      val = &Core::SetOf<T>::get(str);
    }
 
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, int& val);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, unsigned int& val);
 
    
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, double& val);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, bool& val);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Math::Expression& val);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Math::Expression*& val);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Vector& vec);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Vector*& vec);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Point& pt);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Point*& pt);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Quaternion& quat);
 
    template<> void
    XmlParser::ConvertStringTo(const TiXmlElement* el, const std::string& str, Geom::Quaternion*& quat);
 
 
    template<typename T>  std::string XmlParser::TypeName() {
      return typeid(T).name();
    }
 
    template<> std::string XmlParser::TypeName<double>();
    template<> std::string XmlParser::TypeName<int>();
    template<> std::string XmlParser::TypeName<unsigned int>();
    template<> std::string XmlParser::TypeName<bool>();
    template<> std::string XmlParser::TypeName<float>();
    template<> std::string XmlParser::TypeName<Geom::Vector>();
    template<> std::string XmlParser::TypeName<Geom::Point>();
    template<> std::string XmlParser::TypeName<Math::Expression>();
 
 
#endif
  }
 
  namespace Attr = Core::Attribute;
  namespace El = Core::Element;
 
}
 
#endif