spdlog_utils.h

 
#ifndef __6f06a5790b0b46cf94fb3cc3cc0cc2d3
#define __6f06a5790b0b46cf94fb3cc3cc0cc2d3
 
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <spdlog/formatter.h>
#include <spdlog/logger.h>
 
#include <Eigen/Core>
#include <memory>
 
namespace lf::base {
 
std::shared_ptr<spdlog::logger> InitLogger(const std::string& name);
 
// clang-format off
// clang-format on
class LineFeedFormatter final : public spdlog::formatter {
 public:
  explicit LineFeedFormatter(
      std::unique_ptr<spdlog::formatter> wrapped_formatter);
 
  LineFeedFormatter(const LineFeedFormatter&) = delete;
  LineFeedFormatter(LineFeedFormatter&&) = default;
  LineFeedFormatter& operator=(const LineFeedFormatter&) = delete;
  LineFeedFormatter& operator=(LineFeedFormatter&&) = default;
  ~LineFeedFormatter() override = default;
 
  void format(const spdlog::details::log_msg& msg,
              spdlog::memory_buf_t& dest) override;
 
  [[nodiscard]] std::unique_ptr<formatter> clone() const override;
 
 private:
  std::unique_ptr<spdlog::formatter> wrapped_formatter_;
};
 
namespace internal {
template <class MATRIX, typename = std::enable_if_t<std::is_base_of_v<
                            Eigen::DenseBase<MATRIX>, MATRIX>>>
using enable_if_eigen = MATRIX;
}  // namespace internal
 
}  // namespace lf::base
 
 
// The following is needed to prohibit fmt to treat Eigen matrices/arrays as
// ranges.
template <class MATRIX>
struct fmt::is_range<lf::base::internal::enable_if_eigen<MATRIX>, char> {
  static FMT_CONSTEXPR_DECL const bool value = false;
};
 
template <class MATRIX>
struct fmt::formatter<lf::base::internal::enable_if_eigen<MATRIX>> {
  constexpr auto parse(const format_parse_context& ctx) {
    const auto* it = ctx.begin();
    const auto* end = ctx.end();
 
    if (it != end && *it != '}') {
      throw format_error("invalid format");
    }
 
    return it;
  }
 
  template <typename FormatContext>
  auto format(const MATRIX& m, FormatContext& ctx) {
    std::stringstream ss;
    ss << m.format(clean_fmt);
 
    auto it = ctx.out();
    auto str = ss.str();
    std::copy(str.begin(), str.end(), it);
    return it;
  }
 
 private:
  static inline const Eigen::IOFormat clean_fmt =
      Eigen::IOFormat(4, 0, ", ", "\n", "[", "]");
};
 
#endif  // __6f06a5790b0b46cf94fb3cc3cc0cc2d3