🎨 Allow logging to work with custom levels

Problem:
- Many logging backends have varying ideas of what a log level is. The MIPI-SysT
  spec defines two user-defined values. It would be nice to use a strongly-typed
  enumeration in application code that can re-spell the `USER1` and `USER2`
  values.

Solution:
- Make logging level-agnostic.
- The MIPI-SysT levels are provided for default use, but they aren't required.

Author: elbeno

include/log/catalog/mipi_encoder.hpp

@@ -20,13 +20,13 @@
 
 namespace logging::mipi {
 namespace detail {
-template <logging::level L, typename S, typename... Args>
-constexpr auto to_message() {
+template <auto L, typename S, typename... Args> constexpr auto to_message() {
     constexpr auto s = S::value;
     using char_t = typename std::remove_cv_t<decltype(s)>::value_type;
     return [&]<std::size_t... Is>(std::integer_sequence<std::size_t, Is...>) {
         return sc::message<
-            L, sc::undefined<sc::args<Args...>, char_t, s[Is]...>>{};
+            static_cast<logging::level>(L),
+            sc::undefined<sc::args<Args...>, char_t, s[Is]...>>{};
     }(std::make_integer_sequence<std::size_t, std::size(s)>{});
 }
 
@@ -113,7 +113,7 @@ template <typename TDestinations> struct log_handler {
     template <typename Env, typename Msg>
     ALWAYS_INLINE auto log_msg(Msg msg) -> void {
         msg.apply([&]<typename S, typename... Args>(S, Args... args) {
-            constexpr auto L = get_level(Env{}).value;
+            constexpr auto L = stdx::to_underlying(get_level(Env{}).value);
             using Message = decltype(detail::to_message<L, S, Args...>());
             using Module =
                 decltype(detail::to_module<get_module(Env{}).value>());
@@ -174,7 +174,7 @@ template <typename TDestinations> struct log_handler {
             dests);
     }
 
-    template <logging::level Level, std::same_as<std::uint32_t>... MsgDataTypes>
+    template <auto Level, std::same_as<std::uint32_t>... MsgDataTypes>
     ALWAYS_INLINE auto dispatch_message(string_id id,
                                         [[maybe_unused]] module_id m,
                                         MsgDataTypes... msg_data) -> void {

test/log/CMakeLists.txt

@@ -1,4 +1,11 @@
-add_tests(FILES log module_id env LIBRARIES cib_log)
+add_tests(
+    FILES
+    level
+    log
+    module_id
+    env
+    LIBRARIES
+    cib_log)
 add_tests(FILES fmt_logger LIBRARIES cib_log_fmt)
 add_tests(FILES mipi_encoder mipi_logger LIBRARIES cib_log_mipi)
 

test/log/level.cpp

@@ -0,0 +1,68 @@
+#include <log/catalog/mipi_encoder.hpp>
+#include <log/fmt/logger.hpp>
+#include <log/level.hpp>
+#include <sc/format.hpp>
+
+#include <stdx/ct_conversions.hpp>
+#include <stdx/ct_string.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cstdint>
+#include <iterator>
+#include <string>
+#include <type_traits>
+
+namespace {
+enum struct custom_level { THE_ONE_LEVEL = 5 };
+
+std::string buffer{};
+} // namespace
+
+template <>
+inline auto logging::config<> =
+    logging::fmt::config{std::back_inserter(buffer)};
+
+template <custom_level L>
+struct fmt::formatter<std::integral_constant<custom_level, L>> {
+    constexpr static auto parse(format_parse_context &ctx) {
+        return ctx.begin();
+    }
+
+    template <typename FormatContext>
+    auto format(std::integral_constant<custom_level, L>,
+                FormatContext &ctx) const {
+        return ::fmt::format_to(ctx.out(), stdx::enum_as_string<L>());
+    }
+};
+
+TEST_CASE("fmt logger works with custom level", "[level]") {
+    CIB_LOG_ENV(logging::get_level, custom_level::THE_ONE_LEVEL);
+    buffer.clear();
+    CIB_LOG(logging::default_flavor_t, "Hello");
+    CAPTURE(buffer);
+    CHECK(buffer.find("THE_ONE_LEVEL [default]:") != std::string::npos);
+}
+
+template <typename> auto catalog() -> string_id { return 0xdeadbeef; }
+template <typename> auto module() -> module_id { return 0x5a; }
+
+namespace {
+int log_calls{};
+
+struct test_destination {
+    auto log_by_args(std::uint32_t header, auto id, auto &&...) {
+        CHECK(header == 0x01'5a'00'53);
+        CHECK(id == 0xdeadbeef);
+        ++log_calls;
+    }
+};
+} // namespace
+
+TEST_CASE("mipi logger works with custom level", "[level]") {
+    log_calls = 0;
+    CIB_LOG_ENV(logging::get_level, custom_level::THE_ONE_LEVEL);
+    auto cfg = logging::mipi::config{test_destination{}};
+    cfg.logger.log_msg<cib_log_env_t>(sc::format("Hello {} {}"_sc, 17, 42));
+    CHECK(log_calls == 1);
+}

test/log/mipi_encoder.cpp

@@ -61,12 +61,6 @@ expected_msg_header(logging::level level, module_id m,
                   : expected_short32_header();
 }
 
-template <auto ExpectedId> struct test_log_id_destination {
-    template <typename Id> static auto log_by_args(Id id) {
-        CHECK(id == ((ExpectedId << 4u) | 1u));
-    }
-};
-
 int num_log_args_calls{};
 
 constexpr auto check = [](auto value, auto expected) {