From a442c77c9a3a7e089537d08895610888fd71484e Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sat, 12 May 2018 22:55:51 +0200
Subject: [PATCH] Changes code style to Google Style. Renames namespace meta to
 internal and put copy functions int it. Replaced constexpr by FMT_CONSTEXPR.
 Replaced std::ptrdiff_t by std::size_t.

---
 include/fmt/ranges.h | 281 +++++++++++++++++++++----------------------
 test/ranges-test.cc  |  59 +++++++--
 2 files changed, 187 insertions(+), 153 deletions(-)

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index e8465475..78f09622 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -24,201 +24,196 @@ namespace fmt {
 
 template <typename Char>
 struct formatting_base {
-	template <typename ParseContext>
-	FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 };
 
 template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char>
-{
-	Char prefix = '{';
-	Char delimiter = ',';
-	Char postfix = '}';
-	bool add_spaces = true;
+struct formatting_range : formatting_base<Char> {
+  Char prefix = '{';
+  Char delimiter = ',';
+  Char postfix = '}';
+  static FMT_CONSTEXPR bool add_spaces = false;
 };
 
 template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char>
-{
-	Char prefix = '[';
-	Char delimiter = ',';
-	Char postfix = ']';
-	bool add_spaces = true;
+struct formatting_tuple : formatting_base<Char> {
+  Char prefix = '[';
+  Char delimiter = ',';
+  Char postfix = ']';
+  static FMT_CONSTEXPR bool add_spaces = false;
 };
 
-template<typename RangeT, typename OutputIterator>
+namespace internal {
+
+template <typename RangeT, typename OutputIterator>
 void copy(const RangeT &range, OutputIterator out) {
-	for (const auto& it : range) {
-		*out++ = it;
-	}
+  for (const auto &it : range) {
+    *out++ = it;
+  }
 }
 
-template<typename OutputIterator>
+template <typename OutputIterator>
 void copy(const char *str, OutputIterator out) {
-	const char* p_curr = str;
-	while (*p_curr) {
-		*out++ = *p_curr++;
-	}
+  const char *p_curr = str;
+  while (*p_curr) {
+    *out++ = *p_curr++;
+  }
 }
 
-template<typename OutputIterator>
-void copy(const char ch, OutputIterator out) {
-	*out++ = ch;
+template <typename OutputIterator>
+void copy(char ch, OutputIterator out) {
+  *out++ = ch;
 }
 
-} // namespace fmt
+}  // namespace internal
 
-
-namespace fmt {
-namespace meta {
+namespace internal {
 
 /// Return true value if T has std::string interface, like std::string_view.
-template<typename T>
+template <typename T>
 class is_like_std_string {
-	template<typename U> static auto check(U* p) -> decltype(
-		p->find('a')
-		, p->length()
-		, p->data()
-		, int());
-	template<typename  > static void check(...);
-public:
-	static const bool value = !std::is_void< decltype(check<T>(nullptr)) >::value;
+  template <typename U>
+  static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int());
+  template <typename>
+  static void check(...);
+
+ public:
+  static FMT_CONSTEXPR bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
-template<typename T>
-constexpr bool is_like_std_string_v = is_like_std_string<T>::value;
+template <typename T>
+FMT_CONSTEXPR bool is_like_std_string_v = is_like_std_string<T>::value;
 
-template<typename... Ts>
+template <typename... Ts>
 struct conditional_helper {};
 
-template<typename T, typename _ = void>
+template <typename T, typename _ = void>
 struct is_range_ : std::false_type {};
 
-template<typename T>
-struct is_range_<T,
-	std::conditional_t< false,
-	conditional_helper<
-	decltype(std::declval<T>().begin()),
-	decltype(std::declval<T>().end())
-	>, void>
-> : std::true_type {};
-
-template<typename T>
-constexpr bool is_range_v = is_range_<T>::value && !is_like_std_string<T>::value;
+template <typename T>
+struct is_range_<T, std::conditional_t<false,
+                 conditional_helper<decltype(std::declval<T>().begin()),
+                                    decltype(std::declval<T>().end())>,
+                 void>> : std::true_type {};
 
+template <typename T>
+FMT_CONSTEXPR bool is_range_v = is_range_<T>::value && !is_like_std_string<T>::value;
 
 /// tuple_size and tuple_element check.
-template<typename T>
+template <typename T>
 class is_tuple_like_ {
-	template<typename U> static auto check(U* p) -> decltype(
-		std::tuple_size< U >::value,
-		std::declval<typename std::tuple_element<0, U>::type>(),
-		int());
-	template<typename  > static void check(...);
-public:
-	static constexpr bool value = !std::is_void< decltype(check<T>(nullptr)) >::value;
+  template <typename U>
+  static auto check(U *p)
+      -> decltype(std::tuple_size<U>::value,
+                  std::declval<typename std::tuple_element<0, U>::type>(), int());
+  template <typename>
+  static void check(...);
+
+ public:
+  static FMT_CONSTEXPR bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
-template<typename T>
-constexpr bool is_tuple_like_v = is_tuple_like_<T>::value && !is_range_<T>::value;
-
+template <typename T>
+FMT_CONSTEXPR bool is_tuple_like_v = is_tuple_like_<T>::value && !is_range_<T>::value;
 
 //=--------------------------------------------------------------------------------------------------------------------
-template<size_t... Is, class Tuple, class F>
-void for_each(std::index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
-	using std::get;
-	// using free function get<I>(T) now.
-	const int _[] = { 0,
-		((void)f(get<Is>(tup)),
-		0)... };
-	(void)_; // blocks warnings
+template <size_t... Is, class Tuple, class F>
+void for_each(std::index_sequence<Is...>, Tuple &&tup, F &&f) noexcept {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
 }
 //=--------------------------------------------------------------------------------------------------------------------
-template<class T>
-constexpr std::make_index_sequence<std::tuple_size<T>::value>
-get_indexes(T const&) { return {}; }
+template <class T>
+FMT_CONSTEXPR std::make_index_sequence<std::tuple_size<T>::value> 
+get_indexes(T const &) { return {}; }
 
 //=--------------------------------------------------------------------------------------------------------------------
-template<class Tuple, class F>
-void for_each(Tuple&& tup, F&& f) {
-	const auto indexes = get_indexes(tup);
-	for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+template <class Tuple, class F>
+void for_each(Tuple &&tup, F &&f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
 }
 
-} // namespace meta
-} // namespace fmt
-
-namespace fmt {
+}  // namespace internal
 
 // =====================================================================================================================
-template<typename TupleT, typename Char>
-struct formatter< TupleT, Char
-	, std::enable_if_t<fmt::meta::is_tuple_like_v<TupleT>> >
-{
-	fmt::formatting_tuple<Char> formating;
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, std::enable_if_t<fmt::internal::is_tuple_like_v<TupleT>>> {
+  fmt::formatting_tuple<Char> formating;
 
-	template <typename ParseContext>
-	FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-		return formating.parse(ctx);
-	}
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formating.parse(ctx);
+  }
 
-	template <typename FormatContext = format_context>
-	auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
-		auto out = ctx.out();
-		std::ptrdiff_t i = 0;
-		fmt::copy(formating.prefix, out);
-		fmt::meta::for_each(values, [&](const auto &v) {
-			if (i++ > 0) { fmt::copy(formating.delimiter, out); }
-			if (formating.add_spaces) { format_to(out, " {}", v); }
-			else { format_to(out, "{}", v); }
-		});
-		if (formating.add_spaces) { *out++ = ' '; }
-		fmt::copy(formating.postfix, out);
+  template <typename FormatContext = format_context>
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    std::size_t i = 0;
+    internal::copy(formating.prefix, out);
+    internal::for_each(values, [&](const auto &v) {
+      if (i++ > 0) {
+        internal::copy(formating.delimiter, out);
+      }
+      if (formating.add_spaces) {
+        format_to(out, " {}", v);
+      } else {
+        format_to(out, "{}", v);
+      }
+    });
+    if (formating.add_spaces) {
+      *out++ = ' ';
+    }
+    internal::copy(formating.postfix, out);
 
-		return ctx.out();
-	}
+    return ctx.out();
+  }
 };
 
-} // namespace fmt
+template <typename RangeT, typename Char>
+struct formatter<RangeT, Char, std::enable_if_t<fmt::internal::is_range_v<RangeT>>> {
+  static FMT_CONSTEXPR std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the range.
 
+  fmt::formatting_range<Char> formating;
 
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formating.parse(ctx);
+  }
 
-namespace fmt {
-
-
-template<typename RangeT, typename Char>
-struct formatter <RangeT, Char, std::enable_if_t<fmt::meta::is_range_v<RangeT>> >
-{
-	static constexpr std::ptrdiff_t range_length_limit = FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
-
-	fmt::formatting_range<Char> formating;
-
-	template <typename ParseContext>
-	FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-		return formating.parse(ctx);
-	}
-
-	template <typename FormatContext>
-	auto format(const RangeT &values, FormatContext &ctx) -> decltype(ctx.out()) {
-		auto out = ctx.out();
-		fmt::copy(formating.prefix, out);
-		std::ptrdiff_t i = 0;
-		for (const auto& it : values) {
-			if (i > 0) { fmt::copy(formating.delimiter, out); }
-			if (formating.add_spaces) { format_to(out, " {}", it); }
-			else { format_to(out, "{}", it); }
-			if (++i > range_length_limit) {
-				format_to(out, " ... <other elements>");
-				break;
-			}
-		}
-		if (formating.add_spaces) { *out++ = ' '; }
-		fmt::copy(formating.postfix, out);
-		return ctx.out();
-	}
+  template <typename FormatContext>
+  auto format(const RangeT &values, FormatContext &ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    internal::copy(formating.prefix, out);
+    std::size_t i = 0;
+    for (const auto &it : values) {
+      if (i > 0) {
+        internal::copy(formating.delimiter, out);
+      }
+      if (formating.add_spaces) {
+        format_to(out, " {}", it);
+      } else {
+        format_to(out, "{}", it);
+      }
+      if (++i > range_length_limit) {
+        format_to(out, " ... <other elements>");
+        break;
+      }
+    }
+    if (formating.add_spaces) {
+      *out++ = ' ';
+    }
+    internal::copy(formating.postfix, out);
+    return ctx.out();
+  }
 };
 
-} // namespace fmt
-
+}  // namespace fmt
 
 #endif // FMT_RANGES_H_
\ No newline at end of file
diff --git a/test/ranges-test.cc b/test/ranges-test.cc
index 00a33b7b..49d87080 100644
--- a/test/ranges-test.cc
+++ b/test/ranges-test.cc
@@ -20,32 +20,71 @@
 #include <vector>
 #include <array>
 #include <map>
-
+#include <string>
 
 TEST(RangesTest, FormatVector) {
-  std::vector<int32_t> iv{ 1,2,3,5,7,11 };
+  std::vector<int32_t> iv{1, 2, 3, 5, 7, 11};
   auto ivf = fmt::format("{}", iv);
-  EXPECT_EQ("{ 1, 2, 3, 5, 7, 11 }", ivf);
+  EXPECT_EQ("{1,2,3,5,7,11}", ivf);
 }
 
 TEST(RangesTest, FormatVector2) {
-  std::vector<std::vector<int32_t>> ivv{ {1,2},{3,5},{7,11} };
+  std::vector<std::vector<int32_t>> ivv{{1, 2}, {3, 5}, {7, 11}};
   auto ivf = fmt::format("{}", ivv);
-  EXPECT_EQ("{ { 1, 2 }, { 3, 5 }, { 7, 11 } }", ivf);
+  EXPECT_EQ("{{1,2},{3,5},{7,11}}", ivf);
 }
 
 TEST(RangesTest, FormatMap) {
-  std::map<std::string, int32_t>  simap{ {"one",1}, {"two",2} };
-  EXPECT_EQ("{ [ one, 1 ], [ two, 2 ] }", fmt::format("{}", simap));
+  std::map<std::string, int32_t> simap{{"one", 1}, {"two", 2}};
+  EXPECT_EQ("{[one,1],[two,2]}", fmt::format("{}", simap));
 }
 
 TEST(RangesTest, FormatPair) {
   std::pair<int64_t, float> pa1{42, 3.14159265358979f};
-  EXPECT_EQ("[ 42, 3.14159 ]", fmt::format("{}", pa1));
+  EXPECT_EQ("[42,3.14159]", fmt::format("{}", pa1));
 }
 
 TEST(RangesTest, FormatTuple) {
-  std::tuple<int64_t, float, std::string> tu1{42, 3.14159265358979f, "this is tuple"};
-  EXPECT_EQ("[ 42, 3.14159, this is tuple ]", fmt::format("{}", tu1));
+  std::tuple<int64_t, float, std::string> tu1{42, 3.14159265358979f,
+                                              "this is tuple"};
+  EXPECT_EQ("[42,3.14159,this is tuple]", fmt::format("{}", tu1));
 }
 
+#if (__cplusplus > 201402L) || \
+    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
+
+struct my_struct {
+  int32_t i;
+  std::string str;  // can throw
+  template <std::size_t N>
+  decltype(auto) get() const noexcept {
+    if constexpr (N == 0)
+      return i;
+    else if constexpr (N == 1)
+      return fmt::string_view{str};
+  }
+};
+
+template <std::size_t N>
+decltype(auto) get(const my_struct& s) noexcept {
+  return s.get<N>();
+}
+
+namespace std {
+
+template <>
+struct tuple_size<my_struct> : std::integral_constant<std::size_t, 2> {};
+
+template <std::size_t N>
+struct tuple_element<N, my_struct> {
+  using type = decltype(std::declval<my_struct>().get<N>());
+};
+
+}  // namespace std
+
+TEST(RangesTest, FormatStruct) {
+  my_struct mst{13, "my struct"};
+  EXPECT_EQ("[13,my struct]", fmt::format("{}", mst));
+}
+
+#endif // (__cplusplus > 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
\ No newline at end of file