ObserverLoader.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_observers/Observer.h>
#include <mc_observers/api.h>
#include <mc_rtc/config.h>
#include <mc_rtc/loader.h>
 
#include <memory>
#include <mutex>
 
namespace mc_observers
{
 
struct MC_OBSERVERS_DLLAPI ObserverLoader
{
public:
  template<typename... Args>
  static std::shared_ptr<mc_observers::Observer> get_observer(const std::string & name, const Args &... args)
  {
    std::lock_guard<std::mutex> guard{mtx};
    init();
    return observer_loader->create_object(name, args...);
  }
 
  inline static std::string get_observer_runtime_directory(const std::string & name) noexcept
  {
    std::lock_guard<std::mutex> guard{mtx};
    init();
    return observer_loader->get_object_runtime_directory(name);
  }
 
  template<typename RetT, typename... Args>
  static void register_object(const std::string & name, std::function<RetT *(const Args &...)> callback)
  {
    std::unique_lock<std::mutex> guard{mtx};
    init();
    observer_loader->register_object(name, callback);
  }
 
  static inline void update_module_path(const std::vector<std::string> & paths)
  {
    std::lock_guard<std::mutex> guard{mtx};
    init();
    observer_loader->load_libraries(paths);
  }
 
  static inline void clear()
  {
    std::lock_guard<std::mutex> guard{mtx};
    init(true);
    observer_loader->clear();
  }
 
  static bool has_observer(const std::string & name)
  {
    std::lock_guard<std::mutex> guard{mtx};
    init();
    return observer_loader->has_object(name);
  }
 
  static void set_verbosity(bool verbose)
  {
    std::lock_guard<std::mutex> guard{mtx};
    verbose_ = verbose;
    if(observer_loader) { observer_loader->set_verbosity(verbose); }
  }
 
  static std::vector<std::string> available_observers()
  {
    std::lock_guard<std::mutex> guard{mtx};
    init();
    return observer_loader->objects();
  }
 
private:
  static inline void init(bool skip_default_path = false)
  {
    if(!observer_loader)
    {
      try
      {
        std::vector<std::string> default_path = {};
        if(!skip_default_path) { default_path.push_back(mc_rtc::MC_OBSERVERS_INSTALL_PREFIX); }
        observer_loader.reset(
            new mc_rtc::ObjectLoader<mc_observers::Observer>("MC_RTC_OBSERVER_MODULE", default_path, verbose_));
      }
      catch(const mc_rtc::LoaderException & exc)
      {
        mc_rtc::log::error("Failed to initialize ObserverLoader: {}", exc.what());
        throw(exc);
      }
    }
  }
  static std::unique_ptr<mc_rtc::ObjectLoader<mc_observers::Observer>> observer_loader;
  static bool verbose_;
  static std::mutex mtx;
};
 
} // namespace mc_observers