logger.hpp

#ifndef MRS_LIB_LOGGER_HPP_
#define MRS_LIB_LOGGER_HPP_
 
#include <chrono>
#include <format>
#include <utility>
 
#include <rclcpp/clock.hpp>
#include <rclcpp/logger.hpp>
#include <rclcpp/logging.hpp>
#include <rclcpp/node_interfaces/node_clock_interface.hpp>
#include <rclcpp/node_interfaces/node_interfaces.hpp>
#include <rclcpp/node_interfaces/node_logging_interface.hpp>
 
// Macro to expand the tokens further.
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(...) __VA_ARGS__
 
// Macro to generate methods of the logger without repeating them manually for all levels.
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define MRS_LIB_GENERATE_FOR_ALL_LEVELS(MACRO)                                                                                                                 \
  MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(MACRO(debug, DEBUG))                                                                                                  \
  MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(MACRO(info, INFO))                                                                                                    \
  MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(MACRO(warning, WARN))                                                                                                 \
  MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(MACRO(error, ERROR))                                                                                                  \
  MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND(MACRO(fatal, FATAL))                                                                                                  \
  static_assert(true)
 
// Hide the lambda from Doxygen, because it breaks Sphinx rendering.
#define MRS_LIB_LOGGER_UNIQUE_TAG [] {}
 
namespace mrs_lib
{

  class Logger
  {
    using NodeInterfaces = rclcpp::node_interfaces::NodeInterfaces<rclcpp::node_interfaces::NodeLoggingInterface, rclcpp::node_interfaces::NodeClockInterface>;
 
  public:
    using Level = rclcpp::Logger::Level;

    explicit Logger(NodeInterfaces node) : node_interfaces_(std::move(node))
    {
    }

    void set_level(Level level)
    {
      node_interfaces_.get_node_logging_interface()->get_logger().set_level(level);
    }
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define MRS_LIB_GEN_LOG(level, LEVEL)                                                                                                                          \
                                                                                                        \
                                                                                                                             \
                                                                                                                      \
  template <typename... Args>                                                                                                                                  \
  void level(std::format_string<Args...> fmt, Args&&... args)                                                                                                  \
  {                                                                                                                                                            \
    RCLCPP_##LEVEL(get_logger(), "%s", std::format(fmt, std::forward<Args>(args)...).c_str());                                                                 \
  }
 
    MRS_LIB_GENERATE_FOR_ALL_LEVELS(MRS_LIB_GEN_LOG);
#undef MRS_LIB_GEN_LOG
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define MRS_LIB_GEN_LOG_ONCE(level, LEVEL)                                                                                                                     \
                                                                                                   \
                                                                                                                             \
                                                                                                                      \
                                                             \
  template <auto LocTag = MRS_LIB_LOGGER_UNIQUE_TAG, typename... Args>                                                                                         \
  void level##_once(std::format_string<Args...> fmt, Args&&... args)                                                                                           \
  {                                                                                                                                                            \
    RCLCPP_##LEVEL##_ONCE(get_logger(), "%s", std::format(fmt, std::forward<Args>(args)...).c_str());                                                          \
  }
 
    MRS_LIB_GENERATE_FOR_ALL_LEVELS(MRS_LIB_GEN_LOG_ONCE);
#undef MRS_LIB_GEN_LOG_ONCE
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define MRS_LIB_GEN_LOG_THROTTLE(level, LEVEL)                                                                                                                 \
                                                                                    \
                                                                        \
                                                                                                                             \
                                                                                                                      \
  template <auto LocTag = MRS_LIB_LOGGER_UNIQUE_TAG, typename... Args>                                                                                         \
  void level##_throttle(std::chrono::milliseconds duration, std::format_string<Args...> fmt, Args&&... args)                                                   \
  {                                                                                                                                                            \
    RCLCPP_##LEVEL##_THROTTLE(get_logger(), get_clock(), duration.count(), "%s", std::format(fmt, std::forward<Args>(args)...).c_str());                       \
  }
 
    MRS_LIB_GENERATE_FOR_ALL_LEVELS(MRS_LIB_GEN_LOG_THROTTLE);
#undef MRS_LIB_GEN_LOG_THROTTLE
 
  private:
    rclcpp::Logger get_logger()
    {
      return node_interfaces_.get_node_logging_interface()->get_logger();
    }
 
    rclcpp::Clock& get_clock()
    {
      return *node_interfaces_.get_node_clock_interface()->get_clock();
    }
 
    NodeInterfaces node_interfaces_;
  };
 
} // namespace mrs_lib
 
#undef MRS_LIB_LOGGER_UNIQUE_TAG
#undef MRS_LIB_GENERATE_FOR_ALL_LEVELS
#undef MRS_LIB_GENERATE_FOR_ALL_LEVELS_EXPAND
 
#endif // MRS_LIB_LOGGER_HPP_