Macro.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_AssertMsg_H
#define _GranOO_LibUtil_AssertMsg_H
 
#include <string>
#include <vector>
 
// This macro can replace the standard 'assert' macro.
// The UserAssert macro can be used to detect user error.
 
#ifdef SAFE_MODE
#   define SafeModeAssert(condition, message) \
  do { \
    if (!(condition)) { \
      std::vector<std::string> backtrace = GranOO3::Core::AssertMsg::Backtrace(); \
      GranOO3::Core::AssertMsg::RaiseUserAssertion(__LINE__,  __FILE__, #condition, message, backtrace); \
    }                                                               \
  } while (false)
#else
#   define SafeModeAssert(condition, message)
#endif
 
 
 
 
#ifndef NDEBUG
#   define UserAssert(condition, message) \
  do { \
    if (!(condition)) { \
      std::vector<std::string> backtrace = GranOO3::Core::AssertMsg::Backtrace(); \
      GranOO3::Core::AssertMsg::RaiseUserAssertion(__LINE__,  __FILE__, #condition, message, backtrace); \
    }                                                               \
  } while (false)
#else
#   define UserAssert(condition, message) do { } while (false)
#endif
 
// Same as UserAssert
#ifndef NDEBUG
#   define AssertMsg(condition, message) \
  do { \
    if (!(condition)) { \
      std::vector<std::string> backtrace = GranOO3::Core::AssertMsg::Backtrace(); \
      GranOO3::Core::AssertMsg::RaiseUserAssertion(__LINE__,  __FILE__, #condition, message, backtrace); \
    }                                                               \
  } while (false)
#else
#   define AssertMsg(condition, message) do { } while (false)
#endif
 
 
// The InternAssert macro can be used to detect intern error.
#ifndef NDEBUG
#   define InternAssert(condition) \
  do { \
    if (!(condition)) { \
      std::vector<std::string> backtrace = GranOO3::Core::AssertMsg::Backtrace(); \
      GranOO3::Core::AssertMsg::RaiseInternAssertion(__LINE__,  __FILE__, #condition, backtrace); \
    }                                                               \
  } while (false)
#else
#   define InternAssert(condition) do { } while (false)
#endif
 
#ifndef NDEBUG
#   define InternAssertMsg(condition, message)          \
  do { \
    if (!(condition)) { \
      std::vector<std::string> backtrace = GranOO3::Core::AssertMsg::Backtrace(); \
      GranOO3::Core::AssertMsg::RaiseInternAssertionMsg(__LINE__,  __FILE__, #condition, message, backtrace); \
    }                                                               \
  } while (false)
#else
#   define InternAssertMsg(condition, message) do { } while (false)
#endif
 
 
 
namespace GranOO3
{
  namespace Core
  {
 
    class AssertMsg
    {
    public:
      static void RaiseUserAssertion(int line, const std::string& file,
                                     const std::string& condition, const std::string& message, const std::vector<std::string> &backtrace);
      static void RaiseInternAssertion(int line, const std::string& file,
                                       const std::string& condition, const std::vector<std::string> &backtrace);
      static void RaiseInternAssertionMsg(int line, const std::string& file,
                                          const std::string& condition, const std::string& message, const std::vector<std::string> &backtrace);
 
      static std::vector<std::string> Backtrace(int skip = 1);
    };
 
  }
}
 
#define TODO \
  InternAssertMsg(0, "This function is not yet implemented !");
 
 
// Macro to insert hard-coded ascii file
#define GRANOO_DECLARE_EXTERN_FILE(FILE)   \
  extern "C" const char FILE[];     \
  extern "C" const size_t FILE ## _len;
 
#define GRANOO_FILE_TO_STRING(FILE) \
  std::string(FILE, FILE ## _len)
 
// This is a macro to automatic access to class member, for example the macro
// GRANOO_ACCESSOR(Mass, double, mass_); -> will give the 4 members fonctions
//    -        double&    mass()       {return mass_};
//    -  const double&    mass() const {return mass_};
//    -  const double& get_mass() const {return mass_};
//    -  void          set_Mass(const double& val){mass_ = val};
//
// Note that these functions are inlined !
 
 
#define GRANOO_ACCESS_REF(method, type, variable)            \
 \
  type & method      () {return variable;}                   \
 \
  type & RW_ ## method () {return variable;} // Unique name to avoid overloading
 
#define GRANOO_ACCESS_REF_PTR(method, type, variable)               \
  \
  type & method      () {return *variable;}                         \
  \
  type & RW_ ## method () {return *variable;} // Unique name to avoid overloading
 
#define GRANOO_ACCESS_REF_CONST(method, type, variable)      \
 \
  const type & method      () const {return variable;}       \
 \
  const type & RO_ ## method () const {return variable;} // Unique name to avoid overloading
 
#define GRANOO_ACCESS_REF_CONST_PTR(method, type, variable)                     \
 \
  const type & method      () const {return *variable;}                         \
 \
  const type & RO_ ## method () const {return *variable;} // Unique name to avoid overloading
 
#define GRANOO_ACCESS_GET(method, type, variable)        \
 \
  const type & get_ ## method () const {return variable;}
 
#define GRANOO_ACCESS_GET_PTR(method, type, variable)                           \
 \
  const type & get_ ## method () const {return *variable;}
 
#define GRANOO_ACCESS_GET_COPY(method, type, variable)  \
 \
  type get_ ## method () const {return variable;}
 
#define GRANOO_ACCESS_SET(method, type, variable)       \
    \
  void set_ ## method (const type& val) {variable = val;}
 
#define GRANOO_ACCESS_SET_COPY(method, type, variable)  \
    \
  void set_ ## method (type val) {variable = val;}
 
#define GRANOO_ACCESS_SET_POS(method, type, variable)                                      \
    \
  void set_ ## method (const type& val) {               \
    AssertMsg(val >= 0., "The value must be positive"); \
    variable = val;}
 
#define GRANOO_ACCESS(method, type, variable)           \
  GRANOO_ACCESS_REF      (method, type, variable)       \
  GRANOO_ACCESS_REF_CONST(method, type, variable)       \
  GRANOO_ACCESS_GET      (method, type, variable)       \
  GRANOO_ACCESS_SET      (method, type, variable)
 
#define GRANOO_ACCESS_POS(method, type, variable)       \
  GRANOO_ACCESS_GET      (method, type, variable)       \
  GRANOO_ACCESS_SET_POS  (method, type, variable)
 
 
// Export field macro
#define GRANOO_EXPORT_FIELD(CLASS, VTK_DATA_TYPE, ...)  \
  const bool CLASS::register_field_ = RegisterField();  \
  bool CLASS::RegisterField() {                         \
    get_FieldCollector().set_VtkData(VTK_DATA_TYPE);    \
    get_FieldCollector().add(__VA_ARGS__); return true;}
 
#define GRANOO_EXPORT_FIELD_T(CLASS, VTK_DATA_TYPE, ...)    \
  template<typename T>                                      \
  const bool CLASS<T>::register_field_ = RegisterField();   \
  template<typename T> bool CLASS<T>::RegisterField() {     \
    get_FieldCollector().set_VtkData(VTK_DATA_TYPE);        \
    get_FieldCollector().add(__VA_ARGS__); return true;}
 
 
# define GRANOO_CLASS_BASE(CLASS, BASE)                             \
public:                                                             \
  static const bool register_granoo_class_;                         \
  static const unsigned int class_rank_ID;                          \
  static const std::string class_ID() {return #CLASS;}              \
  static Core::SetOf<CLASS>& all(const std::string& id)             \
  {return Core::SetOf<CLASS>::get(id);}                             \
  static CLASS& all(unsigned int index)                             \
  {return Core::SetOf<CLASS>::get()(index);}                \
  static Core::SetOf<CLASS>& all()                                  \
  {return Core::SetOf<CLASS>::get();}                               \
  using Set = Core::SetOf<CLASS>;                                   \
  static const size_t class_num_ID() {return std::hash<std::string>()(#CLASS);} \
  virtual const std::string top_class_ID() const {return class_ID();} \
  virtual const unsigned int top_class_rank_ID() const {return class_rank_ID;}  \
  virtual const size_t global_rank() const                            \
  {return this->Core::Register<CLASS>::get_numeric_ID();}             \
  static Core::FieldCollector<CLASS>& get_FieldCollector()           \
  {return Core::FieldCollector<CLASS>::get();};                       \
  static bool RegisterField();                                        \
  static const bool register_field_;                                  \
  typedef BASE base;                                                  \
  virtual void add(Core::SetOfGeneric* set)                           \
  {Core::SetOf<CLASS>::get_safe(set).add_item_in_class_hierarchy(this, set);}   \
  virtual void erase(Core::SetOfGeneric* set)                                   \
  {Core::SetOf<CLASS>::get_safe(set).erase_item_in_class_hierarchy(this, set);} \
  bool in(const Core::SetOf<CLASS>&set) const                           \
  {return this->Core::Register<CLASS>::belong_to_setof(set);}           \
  bool in(const std::string& id) const                                  \
  {return this->Core::Register<CLASS>::belong_to_setof(id);}
 
 
// Macros that declare and register a GranOO class
# define GRANOO_CLASS(CLASS, BASE)                                                       \
  GRANOO_CLASS_BASE(CLASS, BASE)                                                         \
  template<class T>T& prop()                                                             \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS >,                   \
                                             CLASS>::value>::prop<T, CLASS>(*this);}     \
  template<class T> const T& get_prop() const                                            \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS >,                   \
                                             CLASS>::value>::get_prop<T, CLASS>(*this);} \
  template<class T>T& new_prop()                                                         \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS >,                   \
                                             CLASS>::value>::new_prop<T, CLASS>(*this);} \
  virtual bool is(size_t i) const                                                        \
  {if (i==class_num_ID()) return true; return base::is(i);}                              \
                                                                                         \
  virtual void add_in(const std::string& set_ID)                             \
  {Core::SetOf<CLASS>::pull(set_ID).add_item(this);}
 
 
 
# define GRANOO_CLASS_T(CLASS, TPL, BASE)                                                                     \
  GRANOO_CLASS_BASE_T(CLASS, TPL, BASE)                                                                       \
  template<class T>T& prop()                                                                                  \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS<TPL> >,                                   \
                                             CLASS<TPL> >::value>::template prop<T, CLASS<TPL> >(*this);}     \
  template<class T>const T& get_prop() const                                                                  \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS<TPL> >,                                   \
                                             CLASS<TPL> >::value>::template get_prop<T, CLASS<TPL> >(*this);} \
  template<class T>T& new_prop()                                                                              \
  {return Core::PropWrapper<std::is_base_of< Core::PropClass< CLASS<TPL> >,                                   \
                                             CLASS<TPL> >::value>::template new_prop<T, CLASS<TPL> >(*this);} \
  virtual bool is(size_t i) const                                                                             \
  {if (i==class_num_ID()) return true; return base::is(i);}
 
 
# define GRANOO_CLASS_BASE_T(CLASS, T, BASE)                                             \
public:                                                                                  \
  static const bool register_granoo_class_;                                              \
  static const unsigned int class_rank_ID;                               \
  static const std::string class_ID() {return std::string(#CLASS)+"<"+T::class_ID()+">";}\
  static Core::SetOf<CLASS<T> >& all(const std::string& id)              \
  {return Core::SetOf<CLASS<T> >::get(id);}                              \
  static Core::SetOf<CLASS<T> >& all()                                   \
  {return Core::SetOf<CLASS<T> >::get();}                                \
  using Set = Core::SetOf<CLASS<T> >;                                    \
  static const size_t class_num_ID() {return std::hash<std::string>()(#CLASS "<"#T ">");} \
  virtual const std::string top_class_ID() const {return class_ID();}      \
  virtual const unsigned int top_class_rank_ID() const {return class_rank_ID;}  \
  virtual const size_t global_rank() const                                 \
  {return this->Core::Register<CLASS<T> >::get_numeric_ID();}              \
  static Core::FieldCollector<CLASS<T> >& get_FieldCollector()             \
  {return Core::FieldCollector<CLASS<T> >::get();};                        \
  static bool RegisterField();                                             \
  static const bool register_field_;                                       \
  typedef BASE base;                                                       \
  virtual void add(Core::SetOfGeneric* set)                                \
  {Core::SetOf<CLASS<T> >::get_safe(set).add_item_in_class_hierarchy(this, set);}   \
  virtual void erase(Core::SetOfGeneric* set)                                       \
  {Core::SetOf<CLASS<T> >::get_safe(set).erase_item_in_class_hierarchy(this, set);} \
  bool in(const Core::SetOf<CLASS<T> >&set) const                         \
  {return this->Core::Register<CLASS<T> >::belong_to_setof(set);}         \
  bool in(const std::string& id) const                                    \
  {return this->Core::Register<CLASS<T> >::belong_to_setof(id);}          \
  virtual void add_in(const std::string& set_ID)                      \
  {Core::SetOf<CLASS<T>>::pull(set_ID).add_item(this);}
 
# define GRANOO_CLASS_REGISTER(CLASS)                               \
  const bool CLASS::register_granoo_class_ =                        \
    GranOO3::Core::SetOfManager::get().RegisterGranOOClass<CLASS>(); \
  const unsigned int CLASS::class_rank_ID   =                       \
    GranOO3::Core::Base::affect_class_rank_ID();
 
# define GRANOO_CLASS_REGISTER_T(CLASS, T)                             \
  template<> const bool CLASS<T>::register_granoo_class_ =             \
    GranOO3::Core::SetOfManager::get().RegisterGranOOClass<CLASS<T> >();\
  template<> const unsigned int CLASS<T>::class_rank_ID =              \
     GranOO3::Core::Base::affect_class_rank_ID();
 
 
# define GRANOO_CLASS_INSTANCIATE_TPL(CLASS)    \
  template class Core::Register< CLASS >;       \
  template class Core::SetOf< CLASS >;          \
  template class Core::SetOfMap< CLASS >;       \
  template class Core::NeedSetOf< CLASS >;      \
  template class Core::Signal< CLASS& >;
 
# define GRANOO_CLASS_DECLARE_TPL(CLASS)          \
  extern template class Core::Register< CLASS >;  \
  extern template class Core::SetOf< CLASS >;     \
  extern template class Core::SetOfMap< CLASS >;  \
  extern template class Core::NeedSetOf< CLASS >; \
  extern template class Core::Signal< CLASS& >;
 
 
 
 
# define GRANOO_CLASS_DEFAULT_COLOR(R,G,B,A)                   \
public:                                                        \
  const Core::Color& default_color() const {                   \
    static const Core::Color* c = new Core::Color(R,G,B,A); return *c;}
 
 
#endif