#2397: formatting: use the new format_as to significantly reduce complexity

Author: lifflander

cmake_config.h.in

@@ -97,13 +97,15 @@
   #define INCLUDE_FMT_CORE <fmt/core.h>
   #define INCLUDE_FMT_FORMAT <fmt/format.h>
   #define INCLUDE_FMT_OSTREAM <fmt/ostream.h>
+  #define INCLUDE_FMT_BASE <fmt/base.h>
 
   #define VT_FMT_NAMESPACE_BEGIN namespace fmt {
   #define VT_FMT_NAMESPACE_END }
 #else
   #define INCLUDE_FMT_CORE <fmt-vt/core.h>
   #define INCLUDE_FMT_FORMAT <fmt-vt/format.h>
   #define INCLUDE_FMT_OSTREAM <fmt-vt/ostream.h>
+  #define INCLUDE_FMT_BASE <fmt-vt/base.h>
 
   #define VT_FMT_NAMESPACE_BEGIN namespace fmt { inline namespace vt {
   #define VT_FMT_NAMESPACE_END } }

src/vt/collective/reduce/reduce_scope.h

@@ -48,6 +48,9 @@
 
 #include <unordered_map>
 #include <variant>
+#include <string>
+
+#include INCLUDE_FMT_FORMAT
 
 namespace vt { namespace collective { namespace reduce { namespace detail {
 

src/vt/elm/elm_id.h

@@ -47,6 +47,9 @@
 #include "vt/configs/types/types_type.h"
 #include "vt/configs/types/types_sentinels.h"
 
+#include "vt/cmake_config.h"
+#include INCLUDE_FMT_FORMAT
+
 namespace vt { namespace elm {
 
 /// The underlying element ID type
@@ -81,6 +84,12 @@ struct ElementIDStruct {
   bool isLocatedOnThisNode() const;
 };
 
+inline auto format_as(ElementIDStruct e) {
+  auto fmt_str = "({},{},{},{})";
+  return fmt::format(
+    fmt_str, e.id, e.getHomeNode(), e.curr_node, e.isMigratable()
+  );
+}
 
 }} /* end namespace vt::elm */
 
@@ -95,50 +104,4 @@ struct hash<vt::elm::ElementIDStruct> {
 
 } /* end namespace std */
 
-#include "vt/cmake_config.h"
-#include INCLUDE_FMT_FORMAT
-
-VT_FMT_NAMESPACE_BEGIN
-
-/// Custom fmt formatter/print for \c vt::elm::ElementIDStruct
-template <>
-struct formatter<::vt::elm::ElementIDStruct> {
-  /// Presentation format:
-  ///  - 'x' - hex (default)
-  ///  - 'd' - decimal
-  ///  - 'b' - binary
-  char presentation = 'x';
-
-  /// Parses format specifications of the form ['x' | 'd' | 'b'].
-  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
-    // Parse the presentation format and store it in the formatter:
-    auto it = ctx.begin(), end = ctx.end();
-    if (it != end && (*it == 'x' || *it == 'd' || *it == 'b')) {
-      presentation = *it++;
-    }
-
-    // Check if reached the end of the range:
-    if (it != end && *it != '}') {
-      throw format_error("invalid format");
-    }
-
-    // Return an iterator past the end of the parsed range:
-    return it;
-  }
-
-  /// Formats the epoch using the parsed format specification (presentation)
-  /// stored in this formatter.
-  template <typename FormatContext>
-  auto format(::vt::elm::ElementIDStruct const& e, FormatContext& ctx) const {
-    std::string id_format =
-      presentation == 'b' ? "{:b}" : (presentation == 'd' ? "{:d}" : "{:x}");
-    auto fmt_str = "(" + id_format + ",{},{},{})";
-    return format_to(
-      ctx.out(), fmt_str, e.id, e.getHomeNode(), e.curr_node, e.isMigratable()
-    );
-  }
-};
-
-VT_FMT_NAMESPACE_END
-
 #endif /*INCLUDED_VT_ELM_ELM_ID_H*/

src/vt/epoch/epoch_type.h

@@ -47,6 +47,9 @@
 #include "vt/utils/strong/strong_type.h"
 #include "vt/epoch/epoch_impl_type.h"
 
+#include "vt/cmake_config.h"
+#include INCLUDE_FMT_BASE
+
 namespace vt { namespace epoch {
 
 struct EpochType : Strong<
@@ -94,6 +97,8 @@ constexpr inline EpochType makeEpochZero() {
   return EpochType{static_cast<EpochType::ImplType>(0ull)};
 }
 
+inline auto format_as(EpochType e) { return *e; }
+
 }} /* end namespace vt::epoch */
 
 namespace std {
@@ -108,51 +113,6 @@ struct hash<vt::epoch::EpochType> {
 
 } /* end namespace std */
 
-#include "vt/cmake_config.h"
-#include INCLUDE_FMT_FORMAT
-
-VT_FMT_NAMESPACE_BEGIN
-
-/// Custom fmt formatter/print for \c EpochType
-template <>
-struct formatter<::vt::epoch::EpochType> {
-  /// Presentation format:
-  ///  - 'x' - hex (default)
-  ///  - 'd' - decimal
-  ///  - 'b' - binary
-  char presentation = 'x';
-
-  /// Parses format specifications of the form ['x' | 'd' | 'b'].
-  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
-    // Parse the presentation format and store it in the formatter:
-    auto it = ctx.begin(), end = ctx.end();
-    if (it != end && (*it == 'x' || *it == 'd' || *it == 'b')) {
-      presentation = *it++;
-    }
-
-    // Check if reached the end of the range:
-    if (it != end && *it != '}') {
-      throw format_error("invalid format");
-    }
-
-    // Return an iterator past the end of the parsed range:
-    return it;
-  }
-
-  /// Formats the epoch using the parsed format specification (presentation)
-  /// stored in this formatter.
-  template <typename FormatContext>
-  auto format(::vt::epoch::EpochType const& e, FormatContext& ctx) const {
-    return format_to(
-      ctx.out(),
-      presentation == 'b' ? "{:b}" : (presentation == 'd' ? "{:d}" : "{:x}"),
-      *e
-    );
-  }
-};
-
-VT_FMT_NAMESPACE_END
-
 namespace vt {
 
 /// The strong epoch type for holding a epoch for termination detection

src/vt/epoch/epoch_window.h

@@ -47,6 +47,8 @@
 #include "vt/termination/interval/strong_integral_set.h"
 #include "vt/utils/adt/ranged_counter.h"
 
+#include <memory>
+
 namespace vt { namespace epoch {
 
 /**

src/vt/rdma/rdma_common.h

@@ -115,40 +115,29 @@ using RDMA_ElmMapType = std::function<RDMA_BlockElmRangeType(RDMA_ElmType,RDMA_E
 static constexpr Type uninitialized_rdma_type = Type::Uninitialized;
 static constexpr ByteType rdma_default_byte_size = sizeof(char);
 
-}} //end namespace vt::rdma
-
-VT_FMT_NAMESPACE_BEGIN
-
-template <>
-struct formatter<::vt::rdma::Type> {
-  constexpr auto parse(fmt::format_parse_context& ctx) { return ctx.begin(); }
-
-  template <typename FormatContext>
-  auto format(::vt::rdma::Type t, FormatContext& ctx) const {
-    std::string_view name = "Unknown";
-    switch (t) {
-    case ::vt::rdma::Type::Get:
-      name = "Get";
-      break;
-    case ::vt::rdma::Type::Put:
-      name = "Put";
-      break;
-    case ::vt::rdma::Type::GetOrPut:
-      name = "GetOrPut";
-      break;
-    case ::vt::rdma::Type::Uninitialized:
-      name = "Uninitialized";
-      break;
-    default:
-      name = fmt::format(
-        "{}", static_cast<std::underlying_type_t<::vt::rdma::Type>>(t));
-    }
-
-    return fmt::format_to(ctx.out(), name);
+inline auto format_as(Type t) {
+  std::string_view name = "Unknown";
+  switch (t) {
+  case ::vt::rdma::Type::Get:
+    name = "Get";
+    break;
+  case ::vt::rdma::Type::Put:
+    name = "Put";
+    break;
+  case ::vt::rdma::Type::GetOrPut:
+    name = "GetOrPut";
+    break;
+  case ::vt::rdma::Type::Uninitialized:
+    name = "Uninitialized";
+    break;
+  default:
+    name = "Unknown";
+    break;
   }
-};
+  return name;
+}
 
-VT_FMT_NAMESPACE_END
+}} //end namespace vt::rdma
 
 #define PRINT_CHANNEL_TYPE(rdma_op_type) (                              \
   rdma_op_type == vt::rdma::Type::Get ? "rdma::Get" : (            \

src/vt/termination/interval/interval.h

@@ -218,6 +218,11 @@ struct IntervalCompare {
   }
 };
 
+template <typename DomainT, DomainT sentinel>
+auto format_as(Interval<DomainT, sentinel> i) {
+  return fmt::format("Interval[{}, {}]", i.lower(), i.upper());
+}
+
 }}} /* end namespace vt::term::interval */
 
 namespace vt {
@@ -237,20 +242,4 @@ struct Interval;
 
 }}}
 
-VT_FMT_NAMESPACE_BEGIN
-
-template <typename DomainT, DomainT sentinel>
-struct formatter<::vt::term::interval::Interval<DomainT, sentinel>>
-  : formatter<std::string> {
-  template <typename FormatContext>
-  auto format(
-    const ::vt::term::interval::Interval<DomainT, sentinel>& interval,
-    FormatContext& ctx) const {
-    return format_to(
-      ctx.out(), "Interval[{}, {}]", interval.lower(), interval.upper());
-  }
-};
-
-VT_FMT_NAMESPACE_END
-
 #endif /*INCLUDED_VT_TERMINATION_INTERVAL_INTERVAL_H*/

src/vt/timing/timing.h

@@ -44,12 +44,6 @@
 #if !defined INCLUDED_VT_TIMING_TIMING_H
 #define INCLUDED_VT_TIMING_TIMING_H
 
-#include <string>
-
-#include <EngFormat-Cpp/eng_format.hpp>
-#include "vt/cmake_config.h"
-#include INCLUDE_FMT_CORE
-
 #include "vt/timing/timing_type.h"
 
 namespace vt { namespace timing {
@@ -63,24 +57,4 @@ TimeType getCurrentTime();
 
 }} /* end namespace vt::timing */
 
-VT_FMT_NAMESPACE_BEGIN
-
-template<>
-struct formatter<::vt::TimeTypeWrapper> {
-  template<typename ParseContext>
-  constexpr auto parse(ParseContext& ctx) {
-    return ctx.begin();
-  }
-
-  template<typename FormatContext>
-  auto format(::vt::TimeTypeWrapper const& t, FormatContext& ctx) const {
-    return fmt::format_to(
-      ctx.out(), "{}",
-      to_engineering_string(t.seconds(), 5, eng_exponential, "s")
-    );
-  }
-};
-
-VT_FMT_NAMESPACE_END
-
 #endif /*INCLUDED_VT_TIMING_TIMING_H*/

src/vt/timing/timing_type.h

@@ -47,6 +47,12 @@
 #include <limits>
 #include <algorithm>
 #include <cmath>
+#include <string>
+
+#include <EngFormat-Cpp/eng_format.hpp>
+
+#include "vt/cmake_config.h"
+#include INCLUDE_FMT_BASE
 
 namespace vt {
 
@@ -164,6 +170,10 @@ struct TimeTypeWrapper {
   TimeTypeInternal time_;
 };
 
+inline auto format_as(TimeTypeWrapper t) {
+  return to_engineering_string(t.seconds(), 5, eng_exponential, "s");
+}
+
 using TimeType = TimeTypeWrapper;
 
 } /* end namespace vt */

src/vt/topos/index/dense/dense_array.h

@@ -170,23 +170,12 @@ static_assert(
   "DenseIndexArray must follow the index concept"
 );
 
-}}  // end namespace vt::index
-
-VT_FMT_NAMESPACE_BEGIN
-
-template <typename IndexType, ::vt::index::NumDimensionsType ndim>
-struct formatter<::vt::index::DenseIndexArray<IndexType, ndim>> {
-  constexpr auto parse(fmt::format_parse_context& ctx) { return ctx.begin(); }
+template <typename T, NumDimensionsType nd>
+auto format_as(DenseIndexArray<T, nd> d) {
+  return d.toString();
+}
 
-  template <typename FormatContext>
-  auto format(
-    const ::vt::index::DenseIndexArray<IndexType, ndim>& idx,
-    FormatContext& ctx) const {
-    return fmt::format_to(ctx.out(), idx.toString());
-  }
-};
-
-VT_FMT_NAMESPACE_END
+}}  // end namespace vt::index
 
 #include "vt/topos/index/dense/dense_array.impl.h"