loader.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/DataStore.h>
#include <mc_rtc/loader_api.h>
#include <mc_rtc/logging.h>
 
#include <boost/noncopyable.hpp>
 
#ifndef MC_RTC_BUILD_STATIC
#  include <ltdl.h>
#endif
 
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace mc_rtc
{
 
template<typename T>
struct ObjectLoader;
 
struct MC_RTC_LOADER_DLLAPI LoaderException : public std::exception
{
public:
  LoaderException(const std::string & what) : what_(what) {}
 
  virtual const char * what() const noexcept override { return what_.c_str(); }
 
private:
  std::string what_;
};
 
struct MC_RTC_LOADER_DLLAPI LTDLMutex
{
  static std::mutex MTX;
};
 
struct MC_RTC_LOADER_DLLAPI LTDLHandle
{
  LTDLHandle(const std::string & class_name, const std::string & path, const std::string & rpath, bool verbose);
 
  ~LTDLHandle();
 
  LTDLHandle(const LTDLHandle &) = delete;
  LTDLHandle & operator=(const LTDLHandle &) = delete;
 
  template<typename SymT>
  SymT get_symbol(const std::string & name);
 
  inline bool valid() const { return valid_; }
 
  inline const std::vector<std::string> & classes() const { return classes_; }
 
  inline const std::string & path() const { return path_; }
 
  std::string dir() const;
 
private:
  std::string path_;
  std::string rpath_;
  bool verbose_;
#ifndef MC_RTC_BUILD_STATIC
  lt_dlhandle handle_;
#endif
  bool valid_ = false;
  bool global_ = false;
  bool open_ = false;
  std::vector<std::string> classes_;
 
  bool open();
  void close();
};
 
using LTDLHandlePtr = std::shared_ptr<LTDLHandle>;
 
struct MC_RTC_LOADER_DLLAPI Loader
{
  template<typename T>
  friend struct ObjectLoader;
  typedef std::map<std::string, LTDLHandlePtr> handle_map_t;
  typedef std::function<void(const std::string &, LTDLHandle &)> callback_t;
 
public:
  static callback_t default_cb;
 
  static std::string debug_suffix;
 
protected:
  static bool init();
 
  static bool close();
 
  static void load_libraries(const std::string & class_name,
                             const std::vector<std::string> & paths,
                             handle_map_t & out,
                             bool verbose,
                             callback_t cb);
 
private:
  static unsigned int init_count_;
};
 
template<typename T>
struct ObjectLoader : public boost::noncopyable
{
public:
  ObjectLoader(const std::string & class_name,
               const std::vector<std::string> & paths,
               bool verbose,
               Loader::callback_t cb = Loader::default_cb);
 
  ~ObjectLoader();
 
  bool has_object(const std::string & name) const;
 
  std::vector<std::string> objects() const;
 
  void load_libraries(const std::vector<std::string> & paths, Loader::callback_t cb = Loader::default_cb);
 
  void clear();
 
  void set_verbosity(bool verbose);
 
  template<typename RetT, typename... Args>
  void register_object(const std::string & name, std::function<RetT *(const Args &...)> callback);
 
  template<typename... Args>
  std::shared_ptr<T> create_object(const std::string & name, Args... args);
 
  std::string get_object_runtime_directory(const std::string & name) const noexcept;
 
  struct ObjectDeleter
  {
    ObjectDeleter() {}
    ObjectDeleter(void (*fn)(T *));
    void operator()(T * ptr);
 
  private:
    void (*delete_fn_)(T *) = nullptr;
  };
 
  using unique_ptr = std::unique_ptr<T, ObjectDeleter>;
 
  template<typename... Args>
  unique_ptr create_unique_object(const std::string & name, Args... args);
 
protected:
  std::string class_name;
  bool verbose;
  Loader::handle_map_t handles_;
  mc_rtc::DataStore callbacks_;
  std::unordered_map<std::string, ObjectDeleter> deleters_;
 
  template<typename... Args>
  T * create(const std::string & name, Args... args);
 
  template<typename... Args>
  T * create_from_handles(const std::string & name, Args... args);
 
  template<typename... Args>
  T * create_from_callbacks(const std::string & name, Args... args);
};
 
} // namespace mc_rtc
 
#include <mc_rtc/loader.hpp>