🎨 Refactor string catalog generation

Problem:
- Ad-hoc data structures in `gen_str_catalog.py` are unwieldy.
- Enum lookup was broken by encoding change with `encode_32` etc.

Solution:
- Introduction python classes for `Message` and `Module`; simplify code.
- Add some tests for `gen_str_catalog.py`.
- Fix enum lookup: include enum info inside `encode_32<T>`.

Author: elbeno

include/log/catalog/catalog.hpp

@@ -16,7 +16,7 @@ using module_id = std::uint32_t;
 template <typename> extern auto catalog() -> string_id;
 template <typename> extern auto module() -> module_id;
 
-struct encode_32;
-struct encode_64;
-struct encode_u32;
-struct encode_u64;
+template <typename> struct encode_32;
+template <typename> struct encode_64;
+template <typename> struct encode_u32;
+template <typename> struct encode_u64;

include/log/catalog/mipi_builder.hpp

@@ -16,39 +16,33 @@
 
 namespace logging::mipi {
 template <typename T>
-concept signed_packable =
-    std::signed_integral<T> and sizeof(T) <= sizeof(std::int64_t);
+concept signed_packable = std::signed_integral<stdx::underlying_type_t<T>> and
+                          sizeof(T) <= sizeof(std::int64_t);
 
 template <typename T>
 concept unsigned_packable =
-    std::unsigned_integral<T> and sizeof(T) <= sizeof(std::int64_t);
+    std::unsigned_integral<stdx::underlying_type_t<T>> and
+    sizeof(T) <= sizeof(std::int64_t);
 
 template <typename T>
-concept enum_packable = std::is_enum_v<T> and sizeof(T) <= sizeof(std::int32_t);
-
-template <typename T>
-concept packable =
-    signed_packable<T> or unsigned_packable<T> or enum_packable<T>;
+concept packable = signed_packable<T> or unsigned_packable<T>;
 
 template <typename T> struct encoding;
 
 template <signed_packable T> struct encoding<T> {
     using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
-                                         encode_32, encode_64>;
+                                         encode_32<T>, encode_64<T>>;
     using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
                                        std::int32_t, std::int64_t>;
 };
 
 template <unsigned_packable T> struct encoding<T> {
     using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
-                                         encode_u32, encode_u64>;
+                                         encode_u32<T>, encode_u64<T>>;
     using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
                                        std::uint32_t, std::uint64_t>;
 };
 
-template <enum_packable T>
-struct encoding<T> : encoding<stdx::underlying_type_t<T>> {};
-
 template <packable T> using pack_as_t = typename encoding<T>::pack_t;
 template <packable T> using encode_as_t = typename encoding<T>::encode_t;
 

test/log/encoder.cpp

@@ -146,17 +146,18 @@ TEST_CASE("argument packing", "[mipi]") {
 }
 
 TEST_CASE("argument encoding", "[mipi]") {
+    static_assert(std::same_as<logging::mipi::encode_as_t<std::int32_t>,
+                               encode_32<std::int32_t>>);
+    static_assert(std::same_as<logging::mipi::encode_as_t<std::uint32_t>,
+                               encode_u32<std::uint32_t>>);
+    static_assert(std::same_as<logging::mipi::encode_as_t<std::int64_t>,
+                               encode_64<std::int64_t>>);
+    static_assert(std::same_as<logging::mipi::encode_as_t<std::uint64_t>,
+                               encode_u64<std::uint64_t>>);
     static_assert(
-        std::same_as<logging::mipi::encode_as_t<std::int32_t>, encode_32>);
-    static_assert(
-        std::same_as<logging::mipi::encode_as_t<std::uint32_t>, encode_u32>);
-    static_assert(
-        std::same_as<logging::mipi::encode_as_t<std::int64_t>, encode_64>);
-    static_assert(
-        std::same_as<logging::mipi::encode_as_t<std::uint64_t>, encode_u64>);
-    static_assert(std::same_as<logging::mipi::encode_as_t<char>, encode_32>);
-    static_assert(
-        std::same_as<logging::mipi::encode_as_t<unsigned char>, encode_u32>);
+        std::same_as<logging::mipi::encode_as_t<char>, encode_32<char>>);
+    static_assert(std::same_as<logging::mipi::encode_as_t<unsigned char>,
+                               encode_u32<unsigned char>>);
 }
 
 TEST_CASE("log zero arguments", "[mipi]") {

tools/CMakeLists.txt

@@ -1 +1,3 @@
 mypy_lint(FILES gen_str_catalog.py)
+
+add_unit_test("gen_str_catalog_test" PYTEST FILES "gen_str_catalog_test.py")