Logger.h

Go to the documentation of this file.

/* Copyright 2020 CNRS-AIST JRL */
 
#pragma once
 
#include <iosfwd>
#include <string>
 
#include <jrl-qp/api.h>
#include <jrl-qp/defs.h>
#include <jrl-qp/internal/meta.h>
#include <jrl-qp/utils/toMatlab.h>
 
namespace jrl::qp::utils
{
class JRLQP_DLLAPI Logger
{
public:
  Logger(std::ostream & os, std::string name, std::uint32_t flags = 0) : flags_(flags), iter_(-1), name_(name), os_(&os)
  {
  }
 
  Logger & setFlag(std::uint32_t flag, bool add = true);
 
  Logger & setOutputStream(std::ostream & os);
 
  template<typename... Args>
  void comment(std::uint32_t flag, Args &&... args) const;
  void startIter(int i);
  template<typename... Args>
  void log(std::uint32_t flag, Args &&... args) const;
 
  Logger subLog(const std::string & name) const;
 
  int iter() const
  {
    return iter_;
  }
 
private:
  template<bool b>
  std::ostream & logIter() const;
 
  template<bool b, typename T, typename... Args>
  void log_(const std::string & valName, const T & val, Args &&... args) const;
 
  template<bool b, typename T>
  void log_(const T &) const;
 
  template<bool>
  void log_() const
  {
  }
 
  template<bool b, typename Derived>
  void logVal_(const std::string & valName, const Eigen::EigenBase<Derived> & M) const;
 
  template<bool b, typename T>
  void logVal_(const std::string & valName, const std::vector<T> & v) const;
 
  template<bool b,
           typename Other,
           typename std::enable_if<(!internal::derives_from<Other, Eigen::EigenBase>()), int>::type = 0>
  void logVal_(const std::string & valName, const Other & val) const;
 
  std::uint32_t flags_;
  int iter_;
  std::string name_;
  std::ostream * os_;
};
 
template<>
inline std::ostream & Logger::logIter<true>() const
{
  *os_ << name_ << "(" << iter_ + 1 << ")";
  return *os_;
}
 
template<>
inline std::ostream & Logger::logIter<false>() const
{
  *os_ << name_ << "Data";
  return *os_;
}
 
template<typename... Args>
inline void Logger::comment(std::uint32_t flag, Args &&... args) const
{
  if(flag & flags_) ((*os_ << "% ") << ... << args) << "\n";
}
 
template<typename... Args>
inline void Logger::log(std::uint32_t flag, Args &&... args) const
{
  if(flag & flags_)
  {
    if(flag & constant::noIterationFlag)
      log_<false>(std::forward<Args>(args)...);
    else
      log_<true>(std::forward<Args>(args)...);
  }
}
 
template<bool b, typename T, typename... Args>
inline void Logger::log_(const std::string & valName, const T & val, Args &&... args) const
{
  logVal_<b>(valName, val);
  log_<b>(std::forward<Args>(args)...);
}
 
template<bool, typename T>
inline void Logger::log_(const T &) const
{
  static_assert(internal::always_false<T>::value && "incorrect number of arguments.");
}
 
template<bool b, typename Derived>
inline void Logger::logVal_(const std::string & valName, const Eigen::EigenBase<Derived> & M) const
{
  logIter<b>() << "." << valName << " = " << (toMatlab)M.const_derived() << ";\n";
}
 
template<bool b, typename T>
inline void Logger::logVal_(const std::string & valName, const std::vector<T> & v) const
{
  if(v.empty()) return;
  auto & line = logIter<b>() << "." << valName << " = [";
  for(size_t i = 0; i < v.size() - 1; ++i)
  {
    line << internal::cast_as_underlying_if_enum<T>{}(v[i]) << ", ";
  }
  line << internal::cast_as_underlying_if_enum<T>{}(v.back()) << "];\n";
}
 
template<bool b, typename Other, typename std::enable_if<(!internal::derives_from<Other, Eigen::EigenBase>()), int>::type>
inline void Logger::logVal_(const std::string & valName, const Other & val) const
{
  logIter<b>() << "." << valName << " = " << val << ";\n";
}
} // namespace jrl::qp::utils