SetOf.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_SetOf_hpp_
#define _libDEM_SetOf_hpp_
 
#include <string>
#include <vector>
#include <map>
#include <list>
 
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/export.hpp>
#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>
 
#include <vtkUnstructuredGrid.h>
 
#include "GranOO3/Core/SetOfGeneric.hpp"
#include "GranOO3/Core/SetOfManager.hpp"
#include "GranOO3/Core/SetOfMapBase.hpp"
#include "GranOO3/Core/ExtendedSetOf.hpp"
#include "GranOO3/Core/Signal.hpp"
 
namespace GranOO3
{
  namespace Core
  {
    // ** Clarification & Explanation **
    //
    // 4 class are declared in this file:
    //
    // - "SetOfMap" :            This class contain all the SetOf. This class is a singleton, just one SetOfMap per type is allowed.
    //                           To access a SetOf you need his string's key. Example  SetOfMap<Bond>::get().get_setof("UpperWall").
    //                           You can access the map container by the map() method.
    //
    // - "SetOfBase" :           This class is the base class of SetOf. contain a lot of Usefull method
    //
    // - "SetOf" :               Child class of "SetOfBase". When this class is instanciated, it is automatically registered in the SetOfMap with its strKey.
    //                           A Special Instance of SetOf is the static _globalset. Thanks to Register item are automatically registered
    //                           in this SetOf. This SetOf has always "Global" for string's id.
    //                           Sometimes users need just simple container without registration managing. So use it, but be carefull !
    //
    // - "Register" :  An interface class between the SetOf<type>, globalSetOf<type> and the <type>.
    //                           "Register" manage the registering and the de-registering of the object in SetOf<type> and globalSetOf<type>.
    //
    // - "ExtendedSetOf" :          SetOf own a ExtendedSetOf. The ExtendedSetOf class is only specialized class that can do special treatments on kind
    //                           kind of SetOf<T>. You can ask to tools some specific treamtments for discrete elements etc...
    //
    //
    // **comment**
    //
    // - Easy access method are implemented in IO::Domain class
 
 
    //--------------------------------//
    //            SETOFMAP            //
    //--------------------------------//
    //this class is a singleton, only one map per type is allowed
    template<typename type> class SetOf;
 
    template<typename type>
    class SetOfMap : public SetOfMapBase, public Core::Singleton<SetOfMap<type> >
    {
      GRANOO_SINGLETON_CLASS(SetOfMap);
      friend class SetOf<type>;
 
    public:
      typedef std::map<const std::string, SetOf<type>*> mapType;
 
    public:
      void clear();
      void remove_all_set();
      SetOf<type>& get_setof(const std::string&);
      void change_key(const std::string& oldKey, SetOf<type>& set);
      bool exist(const std::string&) const;
      size_t size() const;
      SetOf<type>& first_setof();
      const SetOf<type>& first_setof() const;
      mapType& map();
      void save_it(boost::archive::text_oarchive&, const unsigned int);
      void load_it(boost::archive::text_iarchive&, const unsigned int);
      void record(boost::archive::text_oarchive&);
      void record(boost::archive::text_iarchive&);
 
      std::ostream& write_ascii(std::ostream& out) const;
      std::istream& read_ascii(std::istream& in);
 
      void clear_globalset();
      size_t item_number() const;
      void to_vtk(vtkUnstructuredGrid*);
      std::string info() const;
 
      std::vector<SetOfGeneric*> get_all_setofgeneric();
      SetOfGeneric& get_setofgeneric(const std::string& setID);
      bool is_set_exist(const std::string& setID) const;
 
    private:
      SetOfMap();
      SetOfMap(const SetOf<type>  &);
      SetOfMap<type>  & operator=(const SetOfMap<type>  &);
      virtual ~SetOfMap();
 
      void add_setof(SetOf<type>&);
      void erase_setof(SetOf<type>&);
 
      //Boost serialization
      friend class boost::serialization::access;
      template<class Archive> void save(Archive&, const unsigned int ) const;
      template<class Archive> void load(Archive&, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
    private:
      typename SetOfMap<type>::mapType _map;
      static SetOfMap<type>* _the_setof_map;
 
 
    };
 
    //--------------------------------//
    //           SETOFBASE            //
    //--------------------------------//
    template<typename type>
    class SetOfBase : public ExtendedSetOf<type>
    {
      friend class SetOfMap<type>;
      friend class ExtendedSetOf<type>;
 
    public:
      // Constructors and destructor
      SetOfBase();
      SetOfBase(const SetOfBase<type>& set);
      virtual ~SetOfBase();
 
      // container size and rank of item
      size_t size() const;
      size_t Size() const;
      size_t get_rank(const type* item) const;
      size_t get_rank(const type& item) const;
      bool is_empty() const;
 
      // Accessing an item
      type* get_item_by_rank(size_t i);
      type& get_item(size_t i);
      type* operator[](size_t i);
      type& operator()(size_t i);
      const type* get_item_by_rank(size_t i) const;
      const type& get_item(size_t i) const;
      const type* operator[](size_t i) const;
      const type& operator()(size_t i) const;
 
      type& first();
      const type& first() const;
 
      type& last();
      const type& last() const;
 
      // Add and erase shortcut
      void add(type& item);
      void erase(type& item);
 
      const std::vector<type *>& get_vector() const;
 
      // Adding items
      virtual void add_item(type* item, bool check = true);
      virtual void add_item(type& item, bool check = true);
      virtual void add_item(std::vector<type *>& vector, bool check = true);
      virtual void add_item(SetOfBase<type>&, bool check = true);
 
      // Removing items
      virtual void erase_item(type* item);
      virtual void erase_item(type& item);
      virtual void clear();
      virtual void clear_and_delete();
      virtual void clear_and_delete_with_progress(const std::string&);
 
      // Check if an item is contained
      bool contain(const type* item) const;
      bool contain(const type& item) const;
 
      typename std::vector<type *>::iterator begin();
      typename std::vector<type *>::iterator end();
 
      typename std::vector<type *>::const_iterator begin() const;
      typename std::vector<type *>::const_iterator end() const;
 
    protected:
      std::vector<type *>  _item_vector;
 
    private:
      friend class boost::serialization::access;
      template<class Archive> void save(Archive& ar, const unsigned int version) const;
      template<class Archive> void load(Archive& ar, const unsigned int version);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
    };
 
    //--------------------------------//
    //              SETOF             //
    //--------------------------------//
    template<class type> class Register;
    class Domain;
 
    template < typename T>
    struct type_wrapper {typedef T type_;};
 
    template<typename type>
    class SetOf : public SetOfBase<type>, public SetOfGeneric
    {
 
      friend class Domain;
      friend class SetOfMap<type>;
      friend struct type_wrapper<type>;
      friend struct type_wrapper<Register<type> >;
 
    public:
      // Usefull for internal use only, NOT DOCUMENTED !
      static std::string class_ID() { return std::string("Core::SetOf<" + type::class_ID()+">");}
      static std::string get_global_str_key() {return std::string ("Global");}
 
      // Static usefull methods
      static SetOf<type>& get_global_set();
      static SetOf<type>& get_setof_by_ID(const std::string& id);
      static SetOf<type>* get_setof_ptr_by_ID(const std::string& id);
      static SetOf<type>& get();
      static SetOf<type>& get(const std::string& id);
      static SetOf<type>& pull(const std::string& id); //It build a new SetOf if it does not exist
      static bool exist(const std::string& id);
      static type& get_item_by_base_class_rank(size_t i);
      static void* get_item_by_base_class_rank(size_t i, size_t classID);
      static SetOf<type>& get_safe(SetOfGeneric* parent);
      static type& first_item();
 
    public:
      // Constructors and destructor
      SetOf(const std::string & id);
      SetOf(SetOfBase<type>& set, const std::string& id);
      virtual ~SetOf();
 
      // Usefull for internal use only, NOT DOCUMENTED !
      std::string get_type_key() const;
 
      // Id management
      void set_ID(const std::string& newId);
      bool is_global_set() const;
 
      // Adding item
      virtual void add_item(type *, bool check = true);
      virtual void add_item(type &, bool check = true);
      virtual void add_item_if_not_indexed(type &);
      virtual void add_item_if_not_indexed(SetOf<type> &);
      virtual void add_item(std::vector<type *> &, bool check = true);
      virtual void add_item(SetOfBase<type>&, bool check = true);
 
      // Removing item
      virtual void erase_item(type *);
      virtual void erase_item(type &);
      virtual void erase_item_if_indexed(type &);
      void clear_and_delete();
      void clear_and_delete_with_progress(const std::string&);
      void clear();
      std::vector<Base*> get_allbase_item();
 
      // Xml
      std::string info() const;
      std::string type_ID() const;
 
      // Experimental for SmartSetOf
      virtual void Debug() const {};
      void add_item_in_class_hierarchy(type *, SetOfGeneric*);   // Add in all subclass set
      void erase_item_in_class_hierarchy(type *, SetOfGeneric*); // erase in all subclass set
 
      std::ostream& write_ascii(std::ostream& out) const;
      std::istream& read_ascii(std::istream& in);
      void add_this_item(type *, bool check = true); // For just adding item in the set
      void erase_this_item(type *);                // For just removing item in the set
 
 
      // Operation
      void make_union(SetOf<type>& set1, SetOf<type>& set2 );
      void make_intersection(SetOf<type>& set1, SetOf<type>& set2);
      void make_difference(SetOf<type>& set1, SetOf<type>& set2);
      bool is_equal(SetOf<type>& set);
      bool has_intersection(SetOf<type>& set);
      bool include(SetOf<type>& set);
      unsigned int common_item(SetOf<type>& set);
 
      // Manage signal
      Signal<type &>& get_signal_add_item();
      Signal<type &>& get_signal_erase_item();
 
    protected:
      SetOf();  // Default constructor is required for boost serialization
 
    private:
      static SetOf<type>* _globalset;
      static void add_to_map(SetOf< type >&);
      static void delete_from_map(SetOf< type >&);
 
      SetOf<typename type::base>* get_base_class_set(SetOfGeneric*);
 
      //Boost serialization
      friend class boost::serialization::access;
      template<class Archive> void save(Archive&, const unsigned int ) const;
      template<class Archive> void load(Archive&, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
    private:
      SetOf<typename type::base>* _childset;
      Signal<type &> _signal_add;
      Signal<type &> _signal_erase;
    };
 
    //--------------------------------//
    //           REGISTER             //
    //--------------------------------//
    template<class type>
    class Register
    {
 
      friend class SetOf<type>;
 
    public:
      // Constructors and destructor
      Register();
      virtual ~Register();
 
      // Usefull for internal use only, NOT DOCUMENTED !
      void erase_from_all_setof();
 
      // SetOf management
      bool belong_to_setof(const std::string& setOfId) const;
      bool belong_to_setof(const SetOf<type>& set) const;
      std::list< SetOf<type>* > & get_setof_list();
 
      // get_ a unique numeric id
      unsigned long long int get_numeric_ID() const;
 
    private:
      void add_setof(SetOf<type>&);
      void erase_setof(SetOf<type>&);
      bool already_exist(SetOf<type>&);
 
    private:
      static unsigned long long int _numericID_counter;
 
    private:
      SetOf<type>& _globalset;
      std::list< SetOf<type>* > _setof_list;
      const unsigned long long int _numericID;
    };
 
 
 
  }
}
 
#include "GranOO3/Core/SetOfMap.tpp"
#include "GranOO3/Core/SetOfBase.tpp"
#include "GranOO3/Core/SetOf.tpp"
#include "GranOO3/Core/Register.tpp"
 
 
#endif