Merge pull request #3 from contour-terminal/improvements/template_for

Create template_for utility and small updates

Author: christianparpart

.gitignore

@@ -1,3 +1,5 @@
+[bB]uild
+[bB]uild/**
 compile_commands.json
 .cache/
 out/

include/reflection-cpp/Reflection.hpp include/reflection-cpp/reflection.hppinclude/reflection-cpp/Reflection.hpp renamed to include/reflection-cpp/reflection.hpp

@@ -9,6 +9,7 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 #if __has_include(<source_location>)
     #include <source_location>
@@ -347,8 +348,35 @@ namespace detail
 #elif defined(_MSC_VER)
 #endif
 
+    template <typename... Ts, typename F>
+    constexpr void enumerate_types(F&& f)
+    {
+        [&f]<auto... Is>(std::index_sequence<Is...>) {
+            (f.template operator()<Ts, Is>(), ...);
+        }(std::index_sequence_for<Ts...> {});
+    }
+
+    template <auto... Xs, typename F>
+    constexpr void for_values(F&& f)
+    {
+        (f.template operator()<Xs>(), ...);
+    }
+
+    template <typename T>
+    constexpr bool can_be_formatted = std::is_arithmetic_v<T> || std::is_convertible_v<T, std::string>;
+
 } // namespace detail
 
+template <auto B, auto E, typename F>
+constexpr void template_for(F&& f)
+{
+    using t = std::common_type_t<decltype(B), decltype(E)>;
+
+    [&f]<auto... Xs>(std::integer_sequence<t, Xs...>) {
+        detail::for_values<(B + Xs)...>(f);
+    }(std::make_integer_sequence<t, E - B> {});
+}
+
 template <auto P>
     requires(std::is_member_pointer_v<decltype(P)>)
 consteval std::string_view GetName()
@@ -392,30 +420,55 @@ consteval auto GetName()
 #endif
 }
 
+template <typename Object, typename Callable>
+decltype(auto) CallOnMembers(Object const& object, Callable&& callable)
+{
+    template_for<0, Reflection::CountMembers<Object>>(
+        [&]<auto I>() { callable(Reflection::MemberNameOf<I, Object>, std::get<I>(Reflection::ToTuple(object))); });
+}
+
 template <typename Object>
 std::string Inspect(Object const& object)
 {
-    return [&]<size_t... I>(std::index_sequence<I...>) {
-        std::string str;
-        auto const onMember = [&str]<typename Name, typename Value>(Name&& name, Value&& value) {
-            auto const InspectValue = [&str]<typename T>(T&& arg) {
-                // clang-format off
-                if constexpr (std::is_convertible_v<T, std::string> 
+    std::string str;
+    auto const onMember = [&str]<typename Name, typename Value>(Name&& name, Value&& value) {
+        auto const InspectValue = [&str]<typename T>(T&& arg) {
+            // clang-format off
+            if constexpr (std::is_convertible_v<T, std::string>
                        || std::is_convertible_v<T, std::string_view>
                        || std::is_convertible_v<T, char const*>) // clang-format on
-                    str += std::format("\"{}\"", arg);
-                else
-                    str += std::format("{}", arg);
-            };
-            if (!str.empty())
-                str += ' ';
-            str += name;
-            str += '=';
-            InspectValue(value);
+            {
+                str += std::format("\"{}\"", arg);
+            }
+            else if constexpr (std::is_convertible_v<T, int>) // use std::formattable when available
+            {
+                str += std::format("{}", arg);
+            }
+            else
+            {
+                str += Inspect(arg);
+            }
         };
-        (onMember(MemberNameOf<I, Object>, std::get<I>(Reflection::ToTuple(object))), ...);
-        return str;
-    }(std::make_index_sequence<Reflection::CountMembers<Object>> {});
+        if (!str.empty())
+            str += ' ';
+        str += name;
+        str += '=';
+        InspectValue(value);
+    };
+
+    CallOnMembers(object, onMember);
+    return str;
 }
 
+template <typename Object>
+std::string Inspect(std::vector<Object> const& objects)
+{
+    std::string str;
+    for (auto const& object: objects)
+    {
+        str += Inspect(object);
+        str += '\n';
+    }
+    return str;
+}
 } // namespace Reflection

test-reflection-cpp.cpp

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-#include <reflection-cpp/Reflection.hpp>
+#include <reflection-cpp/reflection.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <iostream>
 #include <string>
 #include <string_view>
 
@@ -13,6 +14,15 @@ struct Person
     int age;
 };
 
+struct TestStruct
+{
+    int a;
+    float b;
+    double c;
+    std::string d;
+    Person e;
+};
+
 enum Color
 {
     Red,
@@ -39,3 +49,22 @@ TEST_CASE("core", "[reflection]")
     auto const result = Reflection::Inspect(p);
     CHECK(result == R"(name="John Doe" email="[email protected]" age=42)");
 }
+
+TEST_CASE("vector", "[reflection]")
+{
+    auto v = std::vector<Person> {};
+    v.emplace_back("John Doe", "[email protected]", 42);
+    v.emplace_back("John Doe", "[email protected]", 43);
+    auto const result = Reflection::Inspect(v);
+    CHECK(result == R"(name="John Doe" email="[email protected]" age=42
+name="John Doe" email="[email protected]" age=43
+)");
+    //clang-format on
+}
+
+TEST_CASE("nested", "[reflection]")
+{
+    auto ts = TestStruct { 1, 2.0f, 3.0, "hello", { "John Doe", "[email protected]", 42 } };
+    auto const result = Reflection::Inspect(ts);
+    CHECK(result == R"(a=1 b=2 c=3 d="hello" e=name="John Doe" email="[email protected]" age=42)");
+}