Export.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 _libCore_Export_hpp_
#define _libCore_Export_hpp_
 
#include <functional>
#include "GranOO3/Core/ExportMethodT.hpp"
 
namespace GranOO3
{
  namespace Core
  {
 
 
    // This is the bindings for the gddViewer export
    class Export
    {
    public:
      template<typename T1,typename T2> static
      void add(const std::string & key,
               const std::string & unit,
               T2 (T1::*Fct)() const);
 
      template<typename T> static
      T get_null_value();
 
      // template<typename T1,typename T2, typename T3> static
      // void AddProp(const std::string& key,
      //                const std::string& unit,
      //                T2 (T1::*Fct)() const);
 
      template<typename T>
      class Prop
      {
      public:
        template<typename T1,typename T2> static
        void add(const std::string& key,
                 const std::string& unit,
                 T2 (T1::*Fct)() const) {
          const std::string the_key = T::class_ID() + ExportMethod::get_separator() + T1::class_ID() + ExportMethod::get_separator() + key;
          T* &item = *new T*(0);
 
          const T1& (T::*Fct1)() const = &T::template get_PropSafe<T1>;
          std::function<const T2 ()> f = std::bind(Fct, std::bind(Fct1, std::ref(item)));
 
          std::vector<std::function<double ()> > vec_function;
          std::vector<std::string> vec_key;
 
          ConvertToDoubleFunction(f, the_key, vec_function, vec_key);
          for (unsigned int i = 0; i < vec_function.size(); ++i) {
            new ExportMethodT<T> (vec_key[i], unit, vec_function[i], item);
          }
        }
 
      };
 
    private:
      template<typename T> static
      void ConvertToDoubleFunction(std::function<T ()>,
                                   const std::string& key,
                                   std::vector<std::function<double ()> >&,
                                   std::vector<std::string>&);
    };
 
 
    template<typename T1,typename T2>
    inline void
    Export::add(const std::string& key,
                const std::string& unit,
                T2 (T1::*Fct)() const) {
      const std::string the_key = T1::class_ID() + ExportMethod::get_separator() + key;
 
      // Dynamic allocation of a pointer of type "T1 *" => will remain after method exit !
      // effective adresse will be given later ....
      T1* &item = *new T1*(0);
      std::function<const T2 ()> f = std::bind(Fct, std::ref(item));
 
      std::vector<std::function<double ()> > vec_function;
      std::vector<std::string> vec_key;
 
      ConvertToDoubleFunction(f, the_key, vec_function, vec_key);
      SafeModeAssert(vec_function.size() == vec_key.size(), "");
      SafeModeAssert(vec_function.size() > 0, "");
 
      for (unsigned int i = 0; i < vec_function.size(); ++i)
        new ExportMethodT<T1> (vec_key[i], unit, vec_function[i], item);
    }
 
  }
}
 
 
#endif