SetOfManager.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 _libDEM_SetOfManager_hpp_
#define _libDEM_SetOfManager_hpp_
 
#include <map>
#include <functional>
 
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
 
 
#include "GranOO3/Core/Singleton.hpp"
 
 
 
 
namespace GranOO3
{
  namespace Core
  {
 
    class SetOfMapBase;
    class SetOfGeneric;
    class Base;
 
    template<class T> class SetOfMap;
    template<class T> class Serialization;
 
    template<class T> struct Read
    {
      static Base* new_object(const std::string& classID, std::istream& in) {
        return Read<typename T::base>::new_object(classID, in);
      }
 
    };
 
 
    class SetOfManager : Core::Singleton<SetOfManager>
    {
      GRANOO_SINGLETON_CLASS(SetOfManager);
 
    public:
      ~SetOfManager();
 
      // SetOfMap management
      void add(SetOfMapBase&);
 
      // SetOf Management
      void ClearAll();
      bool IsClearing();
      void SaveAll(boost::archive::text_oarchive&, const unsigned int);
      void LoadAll(boost::archive::text_iarchive&, const unsigned int);
 
      std::ostream& SaveAllLight(std::ostream& out);
      std::istream& LoadAllLight(std::istream& in);
 
      //Serialization prefix and suffix
      void set_SerializationPrefix(const std::string&);
      void ResetSerializationPrefix();
      const std::string& get_SerializationPrefix();
 
      void set_SerializationSuffix(const std::string&);
      void ResetSerializationSuffix();
      const std::string& get_SerializationSuffix();
 
      template<class T>
      bool RegisterGranOOClass();
 
 
 
      SetOfMapBase& get_setofMapBase(const std::string& id);
      const SetOfMapBase& get_setofMapBase(const std::string& id) const;
      std::map<std::string, SetOfMapBase*> get_allMap() const;
      SetOfGeneric& get_setofgeneric(const std::string& classID, const std::string& setID);
      bool is_set_exist(const std::string& classID, const std::string& setID) const;
 
      std::string info() const;
 
    private:
      SetOfManager();
      SetOfManager(const SetOfManager&) = delete;
      SetOfManager& operator=(const SetOfManager&) = delete;
 
      std::vector<std::string> get_ActiveSetOfMapID();
      void PrintListItem(std::string, unsigned int size, unsigned int rank);
 
    private:
      bool clearing_;
      std::map<std::string, SetOfMapBase*> allSetOfMap_;
      std::map<std::string, std::function<Base*(const std::string&, std::istream&)> > newFunctionMap_;
      std::string serializationPrefix_;
      std::string serializationSuffix_;
    };
 
    template<class T>
    bool
    SetOfManager::RegisterGranOOClass() {
      // Force Instanciation of SetOfMap<T>
      SetOfMap<T>::instanciate();
 
      // Register the new fonction
      std::function<Base*(const std::string&, std::istream&)> f = &Read<T>::new_object;
      if (newFunctionMap_.count(T::class_ID()) == 0)
        newFunctionMap_[T::class_ID()] = f;
 
      return true;
    }
 
    inline bool
    SetOfManager::IsClearing() {
      return clearing_;
    }
 
  }
}
 
 
 
#endif