XmlObjectManager.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_libCore_XmlObjectManager_hpp_
#define _GranOO_libCore_XmlObjectManager_hpp_
 
#include <string>
#include <iterator>
#include <map>
#include <iostream>
#include <typeinfo>
 
#include "GranOO3/Core/TinyXml.hpp"
#include "GranOO3/Core/XmlParser.hpp"
#include "GranOO3/Core/String.hpp"
 
#define GRANOO_XML_READ_SHAPE(CLASS)                                                                   \
  CLASS*                                                                                               \
  CLASS::new_object(const TiXmlElement* el)                                                            \
  {                                                                                                    \
    Core::XmlParser& parser = Core::XmlParser::get();                                                  \
    const std::string id = parser.read_attribute<std::string>(Core::Attribute::GRANOO_OPTIONAL, "ID"); \
                                                                                                       \
    parser.CheckAllowedAttributeValue("Type", Core::ObjectFactory< CLASS >::get_ID());                 \
    const std::string shapeType = parser.read_attribute<std::string>(Attr::GRANOO_REQUIRED, "Type");   \
    CLASS* mf = Core::ObjectFactory< CLASS >::new_object(shapeType);                                   \
    const_cast<std::string&>(mf->_ID) = id;                                                            \
    mf->read_xml_element(parser.get_current_element());                                                \
    return mf;                                                                                         \
  }                                                                                                    \
                                                                                                       \
  void                                                                                                 \
  CLASS::read_xml_element(const TiXmlElement* el)                                                      \
  {                                                                                                    \
    Core::XmlParser& parser = Core::XmlParser::get();                                                  \
    parser.set_current_element(el);                                                                    \
                                                                                                       \
    if (parser.attribute_exist("FrameID"))                                                             \
    {                                                                                                  \
      parser.CheckAllowedAttributeValue("FrameID", Core::XmlObjectManager< Geom::Frame >::get_ID());   \
      const std::string frameId = parser.read_attribute<std::string>("FrameID", "");                   \
      Geom::Frame* f = Core::XmlObjectManager< Geom::Frame >::get_item(frameId);                       \
      set_center(f->get_center());                                                 \
      set_quaternion(f->get_quaternion());                                             \
    }                                                                                                  \
  }                                                                                                    \
                                                                                                       \
  CLASS&                                                                                               \
  CLASS::glob(const std::string& id)                                                                   \
  {                                                                                                    \
    return Core::XmlObjectManager<CLASS>::get(id);                                                     \
  }
 
 
 
namespace GranOO3
{
  namespace Core
  {
    // The definition of 'XmlObjectManager' has moved in the XmlParser.hpp
    // file for circular dependencies problem of headers
 
 
    template<typename T>
    std::map<const std::string, T *> XmlObjectManager<T>::map_;
 
    template<typename T> std::string
    XmlObjectManager<T>::get_list() {
      std::string list = "";
      for (auto& it : get_ID())
        list += it + " ";
      return list;
    }
 
    template<typename T> void
    XmlObjectManager<T>::add_item(const std::string & key, T * item) {
      UserAssert(map_.count(key) == 0,
                 "XmlObjectManager<" + T::class_ID() + ">. Can't add item, the id=" + Core::String::quote(key) +
                 " is already used");
      map_[key] = item;
    }
 
    template<typename T> bool
    XmlObjectManager<T>::exist(const std::string & key) {
      return (map_.count(key) == 1);
    }
 
    template<typename T> T&
    XmlObjectManager<T>::get(const std::string & key) {
      SafeModeAssert(map_.count(key) == 1,
                     "XmlObjectManager<" + T::class_ID() + ">. Can't get item, the id=" + Core::String::quote(key) +
                     " is unknown, please use instead the following id " +
                     get_list());
      return *map_[key];
    }
 
    template<typename T> T *
    XmlObjectManager<T>::get_item(const std::string & key) {
      if (map_.count(key) == 0)
        return 0;
 
 
      return map_[key];
    }
 
    template<typename T> void
    XmlObjectManager<T>::clear() {
      map_.clear();
    }
 
    template<typename T> std::string
    XmlObjectManager<T>::get_ID (const T* item) {
      typename std::map<const std::string, T*>::iterator it;
      for ( it = map_.begin(); it != map_.end(); it++ ) {
        if ((*it).second==item)
          return (*it).first;
      }
      return Core::String::empty_string;
    }
 
    template<typename T> void
    XmlObjectManager<T>::erase_item(const T* item) {
      typename std::map<const std::string, T*>::iterator it;
      for ( it = map_.begin(); it != map_.end(); it++ ) {
        if ((*it).second==item)
          map_.erase(it);
      }
 
 
      UserAssert(0, "can't erase the required item");
    }
 
    template<typename T> T*
    XmlObjectManager<T>::read_element(const TiXmlElement* el, bool ID_required) {
      Core::XmlParser& parser = Core::XmlParser::get();
      parser.set_current_element(el);
 
      std::string id = "";
 
      if (ID_required)
        parser.read_attribute<std::string>(Attribute::GRANOO_REQUIRED, "ID", id);
      else
        parser.read_attribute<std::string>(Attribute::GRANOO_OPTIONAL, "ID", id);
 
      T* item = T::new_object(el);
 
      if (id != "") {
        parser.XmlAssert(map_.count(id) == 0, "The id " + Core::String::quote(id) + " must be unique");
        map_[id] = item;
        map_[id]->add_glob(id);
      }
 
      // Display some info
      granoo::cout << "--> instanciate new " << String::quote(T::class_ID());
      if (id != "")
        granoo::cout << " with ID=" << String::quote(id);
      granoo::cout << granoo::endl;
 
      return item;
 
    }
 
    template<typename T> std::vector<std::string>
    XmlObjectManager<T>::get_ID() {
      typedef std::map<const std::string, T *> MAP;
 
      std::vector<std::string> vec;
      for (typename MAP::iterator it = map_.begin(); it!=map_.end(); ++it)
        vec.push_back(it->first);
 
      return vec;
    }
 
  }
 
}
 
 
 
 
 
#endif // _GranOO_libCore_XmlObjectManager_hpp_