Extend fmt support for partial19 and variant19

Author: arBmind

src/partial19.lib/partial19/Partial.fmt.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "Partial.h"
+
+/// note: for this header you need fmt library (not included as library dependency)
+#include <fmt/format.h>
+
+template<class... Ts, class Char> struct fmt::formatter<partial19::Partial<Ts...>, Char> {
+    constexpr auto parse(fmt::basic_format_parse_context<Char>& ctx) { return ctx.begin(); }
+
+    template<class FormatContext> auto format(partial19::Partial<Ts...> const& t, FormatContext& ctx) const {
+        bool first = true;
+        auto out = ctx.out();
+        t.visitInitialized([&](auto& v) {
+            if (first) {
+                out = fmt::format_to(out, "<[{}", v);
+                first = false;
+            }
+            else {
+                out = fmt::format_to(out, "; {}", v);
+            }
+        });
+        return fmt::format_to(out, "]>");
+    }
+};

src/partial19.lib/partial19/PartialWhich.fmt.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "Partial.h"
+
+/// note: for this header you need fmt library (not included as library dependency)
+#include <fmt/format.h>
+
+/// note: for this header you need strong19 (not included as library dependency)
+#include <strong19/Strong.h>
+
+template<class... Ts, class Char> struct fmt::formatter<partial19::PartialWhich<Ts...>, Char> {
+    constexpr auto parse(fmt::basic_format_parse_context<Char>& ctx) { return ctx.begin(); }
+
+    template<size_t I, class T> static auto format_type_index(bool hit, auto& first, auto& out) -> bool {
+        if (hit) {
+            if constexpr (strong19::is_strong<T>) {
+                if (first) {
+                    out = fmt::format_to(out, "{}", strong19::strong_name<T>);
+                    first = false;
+                }
+                else {
+                    out = fmt::format_to(out, ", {}", strong19::strong_name<T>);
+                }
+            }
+            else {
+                if (first) {
+                    out = fmt::format_to(out, "{}", I);
+                    first = false;
+                }
+                else {
+                    out = fmt::format_to(out, ", {}", I);
+                }
+            }
+        }
+        return true;
+    }
+
+    template<typename FormatContext> auto format(partial19::PartialWhich<Ts...> const& v, FormatContext& ctx) const {
+        if constexpr (sizeof...(Ts) == 0) {
+            return fmt::format_to(ctx.out(), "Which()");
+        }
+        else {
+            return [&]<size_t... Is>(std::index_sequence<Is...> const&) {
+                auto out = fmt::format_to(ctx.out(), "Which<");
+                bool first = true;
+                ((format_type_index<Is, Ts>(v[Is], first, out)), ...);
+                return fmt::format_to(out, ">");
+            }(std::make_index_sequence<sizeof...(Ts)>{});
+        }
+    }
+};

src/partial19.lib/partial19/partial19.qbs

@@ -11,8 +11,10 @@ Product {
     files: [
         "Bitset.h",
         "Partial.equals.h",
+        "Partial.fmt.h",
         "Partial.h",
         "Partial.ostream.h",
+        "PartialWhich.fmt.h",
         "align.h",
     ]
 }

src/variant19.lib/variant19/None.fmt.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "None.h"
+
+/// note: for this header you need fmt library (not included as library dependency)
+#include <fmt/format.h>
+
+template<class... Ts, class Char> struct fmt::formatter<variant19::None, Char> {
+    constexpr auto parse(fmt::basic_format_parse_context<Char>& ctx) { return ctx.begin(); }
+
+    template<typename FormatContext> auto format(variant19::None const&, FormatContext& ctx) const {
+        return fmt::format_to(ctx.out(), "∅");
+    }
+};

src/variant19.lib/variant19/Variant.fmt.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "Variant.h"
+
+/// note: for this header you need fmt library (not included as library dependency)
+#include <fmt/format.h>
+
+template<class... Ts, class Char> struct fmt::formatter<variant19::Variant<Ts...>, Char> {
+    constexpr auto parse(fmt::basic_format_parse_context<Char>& ctx) { return ctx.begin(); }
+
+    template<class FormatContext> auto format(variant19::Variant<Ts...> const& v, FormatContext& ctx) const {
+        if constexpr (sizeof...(Ts) == 0) {
+            return fmt::format_to(ctx.out(), "Variant()");
+        }
+        else {
+            return v.visit([&](auto const& elem) { return fmt::format_to(ctx.out(), "Variant({})", elem); });
+        }
+    }
+};

src/variant19.lib/variant19/VariantWhich.fmt.h

@@ -0,0 +1,38 @@
+#pragma once
+#include "Variant.h"
+
+/// note: for this header you need fmt library (not included as library dependency)
+#include <fmt/format.h>
+
+/// note: for this header you need strong19 (not included as library dependency)
+#include <strong19/Strong.h>
+
+template<class... Ts, class Char> struct fmt::formatter<variant19::VariantWhich<Ts...>, Char> {
+    constexpr auto parse(fmt::basic_format_parse_context<Char>& ctx) { return ctx.begin(); }
+
+    template<size_t I, class T> static auto format_type_index(size_t i, auto& out) -> bool {
+        if (i == I) {
+            if constexpr (strong19::is_strong<T>) {
+                out = fmt::format_to(out, "Which<{}>({})", strong19::strong_name<T>, i);
+            }
+            else {
+                out = fmt::format_to(out, "Which({})", i);
+            }
+        }
+        return (i == I);
+    }
+
+    template<typename FormatContext> auto format(variant19::VariantWhich<Ts...> const& v, FormatContext& ctx) const {
+        if constexpr (sizeof...(Ts) == 0) {
+            return fmt::format_to(ctx.out(), "Which()");
+        }
+        else {
+            return [&]<size_t... Is>(std::index_sequence<Is...> const&) {
+                auto out = ctx.out();
+                ((format_type_index<Is, Ts>(v, out)) || ... ||
+                 (out = fmt::format_to(out, "Which({})", static_cast<size_t>(v)), true));
+                return out;
+            }(std::make_index_sequence<sizeof...(Ts)>{});
+        }
+    }
+};

src/variant19.lib/variant19/variant19.qbs

@@ -9,10 +9,13 @@ Product {
     }
 
     files: [
+        "None.fmt.h",
         "None.h",
         "None.ostream.h",
         "Variant.equals.h",
+        "Variant.fmt.h",
         "Variant.h",
         "Variant.ostream.h",
+        "VariantWhich.fmt.h",
     ]
 }