feat: std::format support for compliant compilers added

example/kalman_filter/kalman.h

@@ -22,7 +22,7 @@
 
 #pragma once
 
-#include <units/bits/external/hacks.h>
+#include <units/bits/fmt_hacks.h>
 #include <units/format.h>
 #include <units/generic/dimensionless.h>
 #include <units/isq/dimensions/time.h>
@@ -151,52 +151,51 @@ constexpr Q covariance_extrapolation(Q uncertainty, Q process_noise_variance)
 }  // namespace kalman
 
 template<typename... Qs>
-struct fmt::formatter<kalman::state<Qs...>> {
+struct STD_FMT::formatter<kalman::state<Qs...>> {
   constexpr auto parse(format_parse_context& ctx)
   {
-    detail::dynamic_specs_handler<format_parse_context> handler(specs, ctx);
-    return detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
+    units::detail::dynamic_specs_handler handler(specs, ctx);
+    return units::detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
   }
 
   template<typename FormatContext>
   auto format(const kalman::state<Qs...>& s, FormatContext& ctx)
   {
-    memory_buffer value_buffer;
+    std::string value_buffer;
     auto to_value_buffer = std::back_inserter(value_buffer);
     if (specs.precision != -1) {
       if constexpr(sizeof...(Qs) == 1)
-        fmt::format_to(to_value_buffer, "{1:%.{0}Q %q}", specs.precision, kalman::get<0>(s));
+        STD_FMT::format_to(to_value_buffer, "{1:%.{0}Q %q}", specs.precision, kalman::get<0>(s));
       else if constexpr(sizeof...(Qs) == 2)
-        fmt::format_to(to_value_buffer, "{{ {1:%.{0}Q %q}, {2:%.{0}Q %q} }}", specs.precision, kalman::get<0>(s), kalman::get<1>(s));
+        STD_FMT::format_to(to_value_buffer, "{{ {1:%.{0}Q %q}, {2:%.{0}Q %q} }}", specs.precision, kalman::get<0>(s), kalman::get<1>(s));
       else
-        fmt::format_to(to_value_buffer, "{{ {1:%.{0}Q %q}, {2:%.{0}Q %q}, {3:%.{0}Q %q} }}", specs.precision, kalman::get<0>(s), kalman::get<1>(s), kalman::get<2>(s));
+        STD_FMT::format_to(to_value_buffer, "{{ {1:%.{0}Q %q}, {2:%.{0}Q %q}, {3:%.{0}Q %q} }}", specs.precision, kalman::get<0>(s), kalman::get<1>(s), kalman::get<2>(s));
     }
     else {
       if constexpr(sizeof...(Qs) == 1)
-        fmt::format_to(to_value_buffer, "{}", kalman::get<0>(s));
+        STD_FMT::format_to(to_value_buffer, "{}", kalman::get<0>(s));
       else if constexpr(sizeof...(Qs) == 2)
-        fmt::format_to(to_value_buffer, "{{ {}, {} }}", kalman::get<0>(s), kalman::get<1>(s));
+        STD_FMT::format_to(to_value_buffer, "{{ {}, {} }}", kalman::get<0>(s), kalman::get<1>(s));
       else
-        fmt::format_to(to_value_buffer, "{{ {}, {}, {} }}", kalman::get<0>(s), kalman::get<1>(s), kalman::get<2>(s));
+        STD_FMT::format_to(to_value_buffer, "{{ {}, {}, {} }}", kalman::get<0>(s), kalman::get<1>(s), kalman::get<2>(s));
     }
 
-    basic_memory_buffer<char> global_format_buffer;
-    units::detail::global_format_specs<char> global_specs = { specs.fill, specs.align, specs.width };
+    std::string global_format_buffer;
+    units::detail::quantity_global_format_specs<char> global_specs = { specs.fill, specs.align, specs.width };
     units::detail::format_global_buffer(std::back_inserter(global_format_buffer), global_specs);
 
-    return fmt::format_to(ctx.out(), fmt::runtime(std::string_view(global_format_buffer.data(), global_format_buffer.size())),
-      std::string_view(value_buffer.data(), value_buffer.size()));
+    return STD_FMT::format_to(ctx.out(), FMT_RUNTIME(global_format_buffer), value_buffer);
   }
 private:
-  detail::dynamic_format_specs<char> specs;
+  units::detail::dynamic_format_specs<char> specs;
 };
 
 template<typename Q>
-struct fmt::formatter<kalman::estimation<Q>> {
+struct STD_FMT::formatter<kalman::estimation<Q>> {
   constexpr auto parse(format_parse_context& ctx)
   {
-    detail::dynamic_specs_handler<format_parse_context> handler(specs, ctx);
-    return detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
+    units::detail::dynamic_specs_handler handler(specs, ctx);
+    return units::detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
   }
 
   template<typename FormatContext>
@@ -209,22 +208,21 @@ struct fmt::formatter<kalman::estimation<Q>> {
         return t.relative();
     }(kalman::get<0>(e.state));
 
-    memory_buffer value_buffer;
+    std::string value_buffer;
     auto to_value_buffer = std::back_inserter(value_buffer);
     if (specs.precision != -1) {
-      fmt::format_to(to_value_buffer, "{0:%.{2}Q} ± {1:%.{2}Q} {0:%q}", q, sqrt(e.uncertainty), specs.precision);
+      STD_FMT::format_to(to_value_buffer, "{0:%.{2}Q} ± {1:%.{2}Q} {0:%q}", q, sqrt(e.uncertainty), specs.precision);
     }
     else {
-      fmt::format_to(to_value_buffer, "{0:%Q} ± {1:%Q} {0:%q}", q, sqrt(e.uncertainty));
+      STD_FMT::format_to(to_value_buffer, "{0:%Q} ± {1:%Q} {0:%q}", q, sqrt(e.uncertainty));
     }
 
-    basic_memory_buffer<char> global_format_buffer;
-    units::detail::global_format_specs<char> global_specs = { specs.fill, specs.align, specs.width };
+    std::string global_format_buffer;
+    units::detail::quantity_global_format_specs<char> global_specs = { specs.fill, specs.align, specs.width };
     units::detail::format_global_buffer(std::back_inserter(global_format_buffer), global_specs);
 
-    return fmt::format_to(ctx.out(), fmt::runtime(std::string_view(global_format_buffer.data(), global_format_buffer.size())),
-      std::string_view(value_buffer.data(), value_buffer.size()));
+    return STD_FMT::format_to(ctx.out(), FMT_RUNTIME(global_format_buffer), value_buffer);
   }
 private:
-  detail::dynamic_format_specs<char> specs;
+  units::detail::dynamic_format_specs<char> specs;
 };

example/kalman_filter/kalman_filter-example_1.cpp

@@ -25,6 +25,7 @@
 #include <units/format.h>
 #include <units/generic/dimensionless.h>
 #include <array>
+#include <iostream>
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex1
 
@@ -32,13 +33,13 @@ using namespace units;
 
 void print_header(const kalman::State auto& initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>9} | {:>8} | {:>14} | {:>14}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>9} | {:>8} | {:>14} | {:>14}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 void print(auto iteration, Dimensionless auto gain, Quantity auto measured, const kalman::State auto& current, const kalman::State auto& next)
 {
-  fmt::print("{:2} | {:9} | {:8} | {:14} | {:14}\n", iteration, gain, measured, current, next);
+  std::cout << STD_FMT::format("{:2} | {:9} | {:8} | {:14} | {:14}\n", iteration, gain, measured, current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_2.cpp

@@ -27,6 +27,7 @@
 #include <units/format.h>
 #include <units/generic/dimensionless.h>
 #include <array>
+#include <iostream>
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex2
 
@@ -34,13 +35,13 @@ using namespace units;
 
 void print_header(const kalman::State auto& initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>8} | {:>23} | {:>23}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>8} | {:>23} | {:>23}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 void print(auto iteration, Quantity auto measured, const kalman::State auto& current, const kalman::State auto& next)
 {
-  fmt::print("{:2} | {:8} | {:.1} | {:.1}\n", iteration, measured, current, next);
+  std::cout << STD_FMT::format("{:2} | {:8} | {:.1} | {:.1}\n", iteration, measured, current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_3.cpp

@@ -27,6 +27,7 @@
 #include <units/format.h>
 #include <units/generic/dimensionless.h>
 #include <array>
+#include <iostream>
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex3
 
@@ -34,13 +35,13 @@ using namespace units;
 
 void print_header(const kalman::State auto& initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>8} | {:>24} | {:>24}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>8} | {:>24} | {:>24}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 void print(auto iteration, Quantity auto measured, const kalman::State auto& current, const kalman::State auto& next)
 {
-  fmt::print("{:2} | {:8} | {:>24.1} | {:>24.1}\n", iteration, measured, current, next);
+  std::cout << STD_FMT::format("{:2} | {:8} | {:>24.1} | {:>24.1}\n", iteration, measured, current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_4.cpp

@@ -28,6 +28,7 @@
 #include <units/format.h>
 #include <units/generic/dimensionless.h>
 #include <array>
+#include <iostream>
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex4
 
@@ -35,13 +36,13 @@ using namespace units;
 
 void print_header(const kalman::State auto& initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>8} | {:>35} | {:>35}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>8} | {:>35} | {:>35}\n", "N", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 void print(auto iteration, Quantity auto measured, const kalman::State auto& current, const kalman::State auto& next)
 {
-  fmt::print("{:2} | {:8} | {:>35.1} | {:>35.1}\n", iteration, measured, current, next);
+  std::cout << STD_FMT::format("{:2} | {:8} | {:>35.1} | {:>35.1}\n", iteration, measured, current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_5.cpp

@@ -25,6 +25,7 @@
 #include <units/format.h>
 #include <units/math.h>
 #include <array>
+#include <iostream>
 
 // Based on: https://www.kalmanfilter.net/kalman1d.html#ex5
 
@@ -33,14 +34,14 @@ using namespace units;
 template<Quantity Q>
 void print_header(kalman::estimation<Q> initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>5} | {:>8} | {:>16} | {:>16}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>5} | {:>8} | {:>16} | {:>16}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 template<Quantity Q, Dimensionless K>
 void print(auto iteration, K gain, Q measured, kalman::estimation<Q> current, kalman::estimation<Q> next)
 {
-  fmt::print("{:2} | {:5%.2Q} | {:8} | {:>16.2} | {:>16.2}\n", iteration, gain, measured, current, next);
+  std::cout << STD_FMT::format("{:2} | {:5%.2Q} | {:8} | {:>16.2} | {:>16.2}\n", iteration, gain, measured, current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_6.cpp

@@ -27,6 +27,7 @@
 #include <units/quantity_point.h>
 #include <units/unit.h>
 #include <array>
+#include <iostream>
 
 // TODO Fix when Celsius is properly supported (#232)
 namespace units::isq::si {
@@ -54,14 +55,14 @@ using namespace units;
 template<QuantityPoint QP>
 void print_header(kalman::estimation<QP> initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>7} | {:>10} | {:>18} | {:>18}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>7} | {:>10} | {:>18} | {:>18}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 template<QuantityPoint QP, Dimensionless K>
 void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
 {
-  fmt::print("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, measured.relative(), current, next);
+  std::cout << STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, measured.relative(), current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_7.cpp

@@ -27,6 +27,7 @@
 #include <units/quantity_point.h>
 #include <units/unit.h>
 #include <array>
+#include <iostream>
 
 // TODO Fix when Celsius is properly supported (#232)
 namespace units::isq::si {
@@ -54,14 +55,14 @@ using namespace units;
 template<QuantityPoint QP>
 void print_header(kalman::estimation<QP> initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>7} | {:>10} | {:>18} | {:>18}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>7} | {:>10} | {:>18} | {:>18}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 template<QuantityPoint QP, Dimensionless K>
 void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
 {
-  fmt::print("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, measured.relative(), current, next);
+  std::cout << STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, measured.relative(), current, next);
 }
 
 int main()

example/kalman_filter/kalman_filter-example_8.cpp

@@ -27,6 +27,7 @@
 #include <units/quantity_point.h>
 #include <units/unit.h>
 #include <array>
+#include <iostream>
 
 // TODO Fix when Celsius is properly supported (#232)
 namespace units::isq::si {
@@ -54,14 +55,14 @@ using namespace units;
 template<QuantityPoint QP>
 void print_header(kalman::estimation<QP> initial)
 {
-  fmt::print("Initial: {}\n", initial);
-  fmt::print("{:>2} | {:>7} | {:>10} | {:>16} | {:>16}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
+  std::cout << STD_FMT::format("Initial: {}\n", initial);
+  std::cout << STD_FMT::format("{:>2} | {:>7} | {:>10} | {:>16} | {:>16}\n", "N", "Gain", "Measured", "Curr. Estimate", "Next Estimate");
 }
 
 template<QuantityPoint QP, Dimensionless K>
 void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
 {
-  fmt::print("{:2} | {:7%.3Q} | {:10%.3Q %q} | {:>16.2} | {:>16.2}\n", iteration, gain, measured.relative(), current, next);
+  std::cout << STD_FMT::format("{:2} | {:7%.3Q} | {:10%.3Q %q} | {:>16.2} | {:>16.2}\n", iteration, gain, measured.relative(), current, next);
 }
 
 int main()