FlatLog.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/log/Logger.h>
#include <mc_rtc/log/utils.h>
#include <mc_rtc/utils_api.h>
 
#include <SpaceVecAlg/SpaceVecAlg>
 
#include <stdexcept>
#include <string>
#include <unordered_map>
 
namespace mc_rtc::log
{
 
namespace details
{
 
template<typename T>
struct GetRawReturnType
{
  using type = T;
};
 
template<int N, int _Options, int _MaxRows, int _MaxCols>
struct GetRawReturnType<Eigen::Matrix<double, N, 1, _Options, _MaxRows, _MaxCols>>
{
  using type = std::conditional_t<N == 2 || N == 3 || N == 6,
                                  Eigen::Matrix<double, N, 1, _Options, _MaxRows, _MaxCols>,
                                  Eigen::VectorXd>;
};
 
} // namespace details
 
struct MC_RTC_UTILS_DLLAPI FlatLog
{
  template<typename T>
  using get_raw_return_t = typename details::GetRawReturnType<T>::type;
 
  FlatLog() = default;
 
  FlatLog(const std::string & fpath);
 
  FlatLog(const FlatLog &) = delete;
  FlatLog & operator=(const FlatLog &) = delete;
 
  FlatLog(FlatLog &&) = default;
  FlatLog & operator=(FlatLog &&) = default;
 
  void load(const std::string & fpath);
 
  void append(const std::string & fpath);
 
  size_t size() const;
 
  std::set<std::string> entries() const;
 
  bool has(const std::string & entry) const;
 
  std::set<LogType> types(const std::string & entry) const;
 
  LogType type(const std::string & entry) const;
 
  LogType type(const std::string & entry, size_t i) const;
 
  template<typename T>
  std::vector<const get_raw_return_t<T> *> getRaw(const std::string & entry) const;
 
  template<typename T>
  std::vector<get_raw_return_t<T>> get(const std::string & entry, const T & def) const;
 
  template<typename T>
  std::vector<get_raw_return_t<T>> get(const std::string & entry) const;
 
  template<typename T>
  get_raw_return_t<T> get(const std::string & entry, size_t i, const T & def) const;
 
  template<typename T>
  const get_raw_return_t<T> * getRaw(const std::string & entry, size_t i) const;
 
  inline const std::vector<std::vector<Logger::GUIEvent>> & guiEvents() const noexcept { return gui_events_; }
 
  inline const std::optional<Logger::Meta> & meta() const noexcept { return meta_; }
 
  struct record
  {
    using unique_void_ptr = std::unique_ptr<void, void (*)(void const *)>;
    record();
    record(LogType t, unique_void_ptr && d) : type(t), data(std::move(d)) {}
    record(const record &) = delete;
    record & operator=(const record &) = delete;
    record(record &&) = default;
    record & operator=(record &&) = default;
    LogType type = mc_rtc::log::LogType::None;
    unique_void_ptr data;
  };
  struct entry
  {
    std::string name;
    std::vector<record> records;
  };
 
private:
  std::vector<entry> data_;
  std::vector<std::vector<Logger::GUIEvent>> gui_events_;
  std::optional<Logger::Meta> meta_;
 
  const std::vector<record> & at(const std::string & entry) const;
 
  size_t index(const std::string & entry, size_t size);
 
  void appendFlat(const std::string & fpath);
 
  void appendBin(const std::string & fpath);
};
 
} // namespace mc_rtc::log
 
#include "FlatLog.hpp"