Logger.h

Go to the documentation of this file.

/*
 * Copyright 2015-2021 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/log/utils.h>
#include <mc_rtc/logging.h>
#include <mc_rtc/utils_api.h>
 
#include <mc_rtc/Configuration.h>
 
#include <memory>
#include <unordered_map>
#include <variant>
 
namespace mc_rtc
{
 
struct LoggerImpl;
struct MC_RTC_UTILS_DLLAPI Logger
{
public:
  static const uint8_t magic[4];
  static const uint8_t version;
  typedef std::function<void(mc_rtc::MessagePackBuilder &)> serialize_fn;
  enum struct Policy
  {
    NON_THREADED = 0,
    THREADED = 1
  };
 
  struct KeyAddedEvent
  {
    log::LogType type;
    std::string key;
  };
 
  struct KeyRemovedEvent
  {
    std::string key;
  };
 
  struct GUIEvent
  {
    std::vector<std::string> category;
    std::string name;
    mc_rtc::Configuration data;
  };
 
  struct StartEvent
  {
  };
 
  using LogEvent = std::variant<KeyAddedEvent, KeyRemovedEvent, GUIEvent, StartEvent>;
 
  struct Meta
  {
    double timestep;
    std::string main_robot;
    std::vector<std::string> main_robot_module;
    std::map<std::string, sva::PTransformd> init;
    std::map<std::string, std::vector<std::vector<double>>> init_q;
    std::map<std::string, std::map<std::string, mc_rtc::Configuration>> calibs;
  };
 
public:
  Logger(const Policy & policy, const std::string & directory, const std::string & tmpl);
 
  ~Logger();
 
  void setup(const Policy & policy, const std::string & directory, const std::string & tmpl);
 
  inline Meta & meta() noexcept { return meta_; }
 
  inline const Meta & meta() const noexcept { return meta_; }
 
  void start(const std::string & ctl_name, double timestep, bool resume = false, double start_t = 0.0);
 
  void open(const std::string & file, double timestep, double start_t = 0.0);
 
  void log();
 
  template<typename CallbackT,
           typename SourceT = void,
           typename std::enable_if<mc_rtc::log::callback_is_serializable<CallbackT>::value, int>::type = 0>
  void addLogEntry(const std::string & name, const SourceT * source, CallbackT && get_fn, bool overwrite = false)
  {
    using ret_t = decltype(get_fn());
    using base_t = typename std::decay<ret_t>::type;
    auto it = find_entry(name);
    if(it != log_entries_.end())
    {
      if(!overwrite)
      {
        log::error("Already logging an entry named {}", name);
        return;
      }
      else
      {
        log_entries_.erase(it);
      }
    }
    auto log_type = log::callback_is_serializable<CallbackT>::log_type;
    log_events_.push_back(KeyAddedEvent{log_type, name});
    log_entries_.push_back({log_type, name, source, [get_fn](mc_rtc::MessagePackBuilder & builder) mutable
                            { mc_rtc::log::LogWriter<base_t>::write(get_fn(), builder); }});
  }
 
  template<typename MemberPtrT,
           MemberPtrT member,
           typename SourceT,
           typename std::enable_if<mc_rtc::log::is_serializable_member<MemberPtrT>::value, int>::type = 0>
  void addLogEntry(const std::string & name, const SourceT * source, bool overwrite = false)
  {
    using MemberT = decltype(source->*member);
    addLogEntry(name, source, [source]() -> const MemberT & { return source->*member; }, overwrite);
  }
 
  template<typename MethodPtrT,
           MethodPtrT method,
           typename SourceT,
           typename std::enable_if<mc_rtc::log::is_serializable_getter<MethodPtrT>::value, int>::type = 0>
  void addLogEntry(const std::string & name, const SourceT * source, bool overwrite = false)
  {
    using MethodRetT = decltype((source->*method)());
    addLogEntry(name, source, [source]() -> MethodRetT { return (source->*method)(); }, overwrite);
  }
 
  template<typename T, typename std::enable_if<mc_rtc::log::callback_is_serializable<T>::value, int>::type = 0>
  void addLogEntry(const std::string & name, T && get_fn, bool overwrite = false)
  {
    addLogEntry(name, static_cast<const void *>(nullptr), std::forward<T>(get_fn), overwrite);
  }
 
  template<typename SourceT, typename CallbackT, typename... Args>
  void addLogEntries(const SourceT * source, const std::string & name, CallbackT && get_fn, Args &&... args)
  {
    addLogEntry(name, source, get_fn);
    addLogEntries(source, std::forward<Args>(args)...);
  }
 
  inline void addGUIEvent(GUIEvent && event) { log_events_.push_back(std::move(event)); }
 
  void removeLogEntry(const std::string & name);
 
  void removeLogEntries(const void * source);
 
  double t() const;
 
  const std::string & path() const;
 
  void flush();
 
  inline size_t size() const { return log_entries_.size(); }
 
  void clear(bool record = true);
 
private:
  struct LogEntry
  {
    log::LogType type;
    std::string key;
    const void * source;
    serialize_fn log_cb;
  };
  std::shared_ptr<LoggerImpl> impl_ = nullptr;
  Meta meta_;
  std::vector<LogEvent> log_events_;
  std::vector<LogEntry> log_entries_;
 
  std::vector<LogEntry>::iterator find_entry(const std::string & name);
 
  template<typename SourceT>
  void addLogEntries(const SourceT *)
  {
  }
};
 
#define MC_RTC_LOG_HELPER(NAME, MEMBER)                                       \
  do                                                                          \
  {                                                                           \
    using ThisT = typename std::remove_pointer<decltype(this)>::type;         \
    logger.addLogEntry<decltype(&ThisT::MEMBER), &ThisT::MEMBER>(NAME, this); \
  } while(0)
 
#define MC_RTC_LOG_GETTER(NAME, METHOD)                                          \
  do                                                                             \
  {                                                                              \
    using MethodRetT = decltype(this->METHOD());                                 \
    logger.addLogEntry(NAME, this, [this]() -> MethodRetT { return METHOD(); }); \
  } while(0)
 
} // namespace mc_rtc