RobotModuleMacros.h

Go to the documentation of this file.

/*
 * Copyright 2015-2020 CNRS-UM LIRMM, CNRS-AIST JRL, BIT
 */
 
#pragma once
 
#include <mc_rbdyn/RobotModule.h>
 
#ifndef MC_RTC_BUILD_STATIC
 
#  include <mc_rtc/version.h>
 
/* Set of macros to assist with the writing of a RobotModule */
 
#  define ROBOT_MODULE_CHECK_VERSION(NAME)                                                                             \
    if(mc_rtc::MC_RTC_VERSION != mc_rtc::version())                                                                    \
    {                                                                                                                  \
      mc_rtc::log::error("{} was compiled with {} but mc_rtc is currently at version {}, you might experience subtle " \
                         "issues and should recompile your code",                                                      \
                         NAME, mc_rtc::MC_RTC_VERSION, mc_rtc::version());                                             \
    }
 
#  define ROBOT_MODULE_COMMON(NAME)                                             \
    ROBOT_MODULE_API void MC_RTC_ROBOT_MODULE(std::vector<std::string> & names) \
    {                                                                           \
      ROBOT_MODULE_CHECK_VERSION(NAME)                                          \
      names = {NAME};                                                           \
    }                                                                           \
    ROBOT_MODULE_API void destroy(mc_rbdyn::RobotModule * ptr)                  \
    {                                                                           \
      delete ptr;                                                               \
    }
 
#  define ROBOT_MODULE_DEFAULT_CONSTRUCTOR(NAME, TYPE)                     \
    extern "C"                                                             \
    {                                                                      \
      ROBOT_MODULE_COMMON(NAME)                                            \
      ROBOT_MODULE_API unsigned int create_args_required()                 \
      {                                                                    \
        return 1;                                                          \
      }                                                                    \
      ROBOT_MODULE_API mc_rbdyn::RobotModule * create(const std::string &) \
      {                                                                    \
        return new TYPE();                                                 \
      }                                                                    \
    }
 
#  define ROBOT_MODULE_CANONIC_CONSTRUCTOR(NAME, TYPE)                          \
    extern "C"                                                                  \
    {                                                                           \
      ROBOT_MODULE_COMMON(NAME)                                                 \
      ROBOT_MODULE_API unsigned int create_args_required()                      \
      {                                                                         \
        return 3;                                                               \
      }                                                                         \
      ROBOT_MODULE_API mc_rbdyn::RobotModule * create(const std::string &,      \
                                                      const std::string & path, \
                                                      const std::string & name) \
      {                                                                         \
        return new TYPE(path, name);                                            \
      }                                                                         \
    }
 
#else
 
#  include <mc_rbdyn/RobotLoader.h>
 
#  define ROBOT_MODULE_DEFAULT_CONSTRUCTOR(NAME, TYPE)                                 \
    namespace                                                                          \
    {                                                                                  \
    static auto registered = []()                                                      \
    {                                                                                  \
      using fn_t = std::function<TYPE *()>;                                            \
      mc_rbdyn::RobotLoader::register_object(NAME, fn_t([]() { return new TYPE(); })); \
      return true;                                                                     \
    }();                                                                               \
    }
 
#  define ROBOT_MODULE_CANONIC_CONSTRUCTOR(NAME, TYPE)                                                          \
    namespace                                                                                                   \
    {                                                                                                           \
    static auto registered = []()                                                                               \
    {                                                                                                           \
      using fn_t = std::function<TYPE *(const std::string &, const std::string &)>;                             \
      mc_rbdyn::RobotLoader::register_object(                                                                   \
          NAME, fn_t([](const std::string & path, const std::string & name) { return new TYPE(path, name); })); \
      return true;                                                                                              \
    }();                                                                                                        \
    }
 
#endif