From df46ef09c9565dabb0455601d4fbf0332b4a2f23 Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Thu, 10 May 2018 16:11:00 +0200
Subject: [PATCH 01/10] Add support for ranges, containers and types tuple
 interface in fmt/ranges.h and some tests.

---
 include/fmt/ranges.h | 224 +++++++++++++++++++++++++++++++++++++++++++
 test/CMakeLists.txt  |   1 +
 test/ranges-test.cc  |  53 ++++++++++
 3 files changed, 278 insertions(+)
 create mode 100644 include/fmt/ranges.h
 create mode 100644 test/ranges-test.cc

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
new file mode 100644
index 00000000..e8465475
--- /dev/null
+++ b/include/fmt/ranges.h
@@ -0,0 +1,224 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include "format.h"
+#include <type_traits>
+
+// output only up to N items from the range.
+#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
+#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#endif
+
+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 Char, typename Enable = void>
+struct formatting_range : formatting_base<Char>
+{
+	Char prefix = '{';
+	Char delimiter = ',';
+	Char postfix = '}';
+	bool add_spaces = true;
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char>
+{
+	Char prefix = '[';
+	Char delimiter = ',';
+	Char postfix = ']';
+	bool add_spaces = true;
+};
+
+template<typename RangeT, typename OutputIterator>
+void copy(const RangeT &range, OutputIterator out) {
+	for (const auto& it : range) {
+		*out++ = it;
+	}
+}
+
+template<typename OutputIterator>
+void copy(const char *str, OutputIterator out) {
+	const char* p_curr = str;
+	while (*p_curr) {
+		*out++ = *p_curr++;
+	}
+}
+
+template<typename OutputIterator>
+void copy(const char ch, OutputIterator out) {
+	*out++ = ch;
+}
+
+} // namespace fmt
+
+
+namespace fmt {
+namespace meta {
+
+/// Return true value if T has std::string interface, like std::string_view.
+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 T>
+constexpr bool is_like_std_string_v = is_like_std_string<T>::value;
+
+template<typename... Ts>
+struct conditional_helper {};
+
+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;
+
+
+/// tuple_size and tuple_element check.
+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 T>
+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<class T>
+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));
+}
+
+} // namespace meta
+} // namespace fmt
+
+namespace fmt {
+
+// =====================================================================================================================
+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 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);
+
+		return ctx.out();
+	}
+};
+
+} // namespace fmt
+
+
+
+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();
+	}
+};
+
+} // namespace fmt
+
+
+#endif // FMT_RANGES_H_
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b0c479cb..07b10a0a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -92,6 +92,7 @@ add_fmt_test(printf-test)
 add_fmt_test(time-test)
 add_fmt_test(util-test mock-allocator.h)
 add_fmt_test(custom-formatter-test)
+add_fmt_test(ranges-test)
 
 # Enable stricter options for one test to make sure that the header is free of
 # warnings.
diff --git a/test/ranges-test.cc b/test/ranges-test.cc
new file mode 100644
index 00000000..7dc770bf
--- /dev/null
+++ b/test/ranges-test.cc
@@ -0,0 +1,53 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifdef WIN32
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#define FMT_HEADER_ONLY   1
+#include "fmt/ranges.h"
+
+#include "gtest/gtest.h"
+
+
+#include <vector>
+#include <array>
+#include <map>
+#include <string_view>
+
+TEST(RangesTest, FormatVector) {
+  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);
+}
+
+TEST(RangesTest, FormatVector2) {
+  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);
+}
+
+TEST(RangesTest, FormatMap) {
+  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));
+}
+
+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));
+}
+

From 50ee89b223f5b19071dfe48f7160a6d1f2a1fca7 Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Thu, 10 May 2018 16:16:47 +0200
Subject: [PATCH 02/10] Removed string_view

---
 test/ranges-test.cc | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/ranges-test.cc b/test/ranges-test.cc
index 7dc770bf..00a33b7b 100644
--- a/test/ranges-test.cc
+++ b/test/ranges-test.cc
@@ -13,16 +13,14 @@
 #define _CRT_SECURE_NO_WARNINGS
 #endif
 
-#define FMT_HEADER_ONLY   1
 #include "fmt/ranges.h"
 
 #include "gtest/gtest.h"
 
-
 #include <vector>
 #include <array>
 #include <map>
-#include <string_view>
+
 
 TEST(RangesTest, FormatVector) {
   std::vector<int32_t> iv{ 1,2,3,5,7,11 };

From 951b743e8d46e9467f3c1aeefad331ad18e27472 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <viz@fb.com>
Date: Sat, 12 May 2018 13:12:04 -0700
Subject: [PATCH 03/10] Fix docs, take 2

---
 doc/build.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/build.py b/doc/build.py
index da9bc774..06363877 100755
--- a/doc/build.py
+++ b/doc/build.py
@@ -90,8 +90,8 @@ def build_docs(version='dev', **kwargs):
                           FMT_USE_RVALUE_REFERENCES=1 \
                           FMT_USE_USER_DEFINED_LITERALS=1 \
                           FMT_API= \
-                          FMT_BEGIN_NAMESPACE=namespace fmt { \
-                          FMT_END_NAMESPACE=}
+                          "FMT_BEGIN_NAMESPACE=namespace fmt {" \
+                          "FMT_END_NAMESPACE=}"
       EXCLUDE_SYMBOLS   = fmt::internal::* StringValue write_str
     '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
   if p.returncode != 0:

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 04/10] 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

From 4cfc6c4c76fa5501c3ccfb544926e1183b7a9c2d Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sat, 12 May 2018 23:02:22 +0200
Subject: [PATCH 05/10] Using FMT_BEGIN_NAMESPACE and FMT_END_NAMESPACE now.

---
 include/fmt/ranges.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index 78f09622..1f4da818 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -20,7 +20,7 @@
 #define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
-namespace fmt {
+FMT_BEGIN_NAMESPACE
 
 template <typename Char>
 struct formatting_base {
@@ -214,6 +214,6 @@ struct formatter<RangeT, Char, std::enable_if_t<fmt::internal::is_range_v<RangeT
   }
 };
 
-}  // namespace fmt
+FMT_END_NAMESPACE
 
 #endif // FMT_RANGES_H_
\ No newline at end of file

From 648b93743ad656f700582404317149d5f08167ed Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sat, 12 May 2018 23:05:28 +0200
Subject: [PATCH 06/10] Fixed build.py conflict.

---
 doc/build.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/build.py b/doc/build.py
index 06363877..cfa52b0d 100755
--- a/doc/build.py
+++ b/doc/build.py
@@ -90,8 +90,8 @@ def build_docs(version='dev', **kwargs):
                           FMT_USE_RVALUE_REFERENCES=1 \
                           FMT_USE_USER_DEFINED_LITERALS=1 \
                           FMT_API= \
-                          "FMT_BEGIN_NAMESPACE=namespace fmt {" \
-                          "FMT_END_NAMESPACE=}"
+                          "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
+                          "FMT_END_NAMESPACE=}}"
       EXCLUDE_SYMBOLS   = fmt::internal::* StringValue write_str
     '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
   if p.returncode != 0:

From f101d628337b31f6e9774a6c9306b5da809f01b8 Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sat, 12 May 2018 23:23:54 +0200
Subject: [PATCH 07/10] Fixed typo.

---
 include/fmt/ranges.h | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index 1f4da818..37157188 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -144,32 +144,33 @@ void for_each(Tuple &&tup, F &&f) {
 // =====================================================================================================================
 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;
+
+  fmt::formatting_tuple<Char> formatting;
 
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formating.parse(ctx);
+    return formatting.parse(ctx);
   }
 
   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::copy(formatting.prefix, out);
     internal::for_each(values, [&](const auto &v) {
       if (i++ > 0) {
-        internal::copy(formating.delimiter, out);
+        internal::copy(formatting.delimiter, out);
       }
-      if (formating.add_spaces) {
+      if (formatting.add_spaces) {
         format_to(out, " {}", v);
       } else {
         format_to(out, "{}", v);
       }
     });
-    if (formating.add_spaces) {
+    if (formatting.add_spaces) {
       *out++ = ' ';
     }
-    internal::copy(formating.postfix, out);
+    internal::copy(formatting.postfix, out);
 
     return ctx.out();
   }
@@ -177,26 +178,27 @@ struct formatter<TupleT, Char, std::enable_if_t<fmt::internal::is_tuple_like_v<T
 
 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;
+  fmt::formatting_range<Char> formatting;
 
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formating.parse(ctx);
+    return formatting.parse(ctx);
   }
 
   template <typename FormatContext>
   auto format(const RangeT &values, FormatContext &ctx) -> decltype(ctx.out()) {
     auto out = ctx.out();
-    internal::copy(formating.prefix, out);
+    internal::copy(formatting.prefix, out);
     std::size_t i = 0;
     for (const auto &it : values) {
       if (i > 0) {
-        internal::copy(formating.delimiter, out);
+        internal::copy(formatting.delimiter, out);
       }
-      if (formating.add_spaces) {
+      if (formatting.add_spaces) {
         format_to(out, " {}", it);
       } else {
         format_to(out, "{}", it);
@@ -206,10 +208,10 @@ struct formatter<RangeT, Char, std::enable_if_t<fmt::internal::is_range_v<RangeT
         break;
       }
     }
-    if (formating.add_spaces) {
+    if (formatting.add_spaces) {
       *out++ = ' ';
     }
-    internal::copy(formating.postfix, out);
+    internal::copy(formatting.postfix, out);
     return ctx.out();
   }
 };

From 7a2099e7de146727c797e4984a3001f3fc6b0584 Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sun, 13 May 2018 00:04:30 +0200
Subject: [PATCH 08/10] Using FMT_CONSTEXPR_DECL for variables. Replaced
 std::enable_if_t by std::std::enable_if<>::type. Replaced variable templates
 by structs.

---
 include/fmt/ranges.h | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index 37157188..02e69001 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -35,7 +35,7 @@ struct formatting_range : formatting_base<Char> {
   Char prefix = '{';
   Char delimiter = ',';
   Char postfix = '}';
-  static FMT_CONSTEXPR bool add_spaces = false;
+  static FMT_CONSTEXPR_DECL const bool add_spaces = false;
 };
 
 template <typename Char, typename Enable = void>
@@ -43,7 +43,7 @@ struct formatting_tuple : formatting_base<Char> {
   Char prefix = '[';
   Char delimiter = ',';
   Char postfix = ']';
-  static FMT_CONSTEXPR bool add_spaces = false;
+  static FMT_CONSTEXPR_DECL const bool add_spaces = false;
 };
 
 namespace internal {
@@ -81,11 +81,9 @@ class is_like_std_string {
   static void check(...);
 
  public:
-  static FMT_CONSTEXPR bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+  static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
-template <typename T>
-FMT_CONSTEXPR bool is_like_std_string_v = is_like_std_string<T>::value;
 
 template <typename... Ts>
 struct conditional_helper {};
@@ -100,7 +98,10 @@ struct is_range_<T, std::conditional_t<false,
                  void>> : std::true_type {};
 
 template <typename T>
-FMT_CONSTEXPR bool is_range_v = is_range_<T>::value && !is_like_std_string<T>::value;
+struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value = is_range_<T>::value && !is_like_std_string<T>::value;
+};
+
 
 /// tuple_size and tuple_element check.
 template <typename T>
@@ -113,11 +114,13 @@ class is_tuple_like_ {
   static void check(...);
 
  public:
-  static FMT_CONSTEXPR bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+  static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
 template <typename T>
-FMT_CONSTEXPR bool is_tuple_like_v = is_tuple_like_<T>::value && !is_range_<T>::value;
+struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value = is_tuple_like_<T>::value && !is_range_<T>::value;
+};
 
 //=--------------------------------------------------------------------------------------------------------------------
 template <size_t... Is, class Tuple, class F>
@@ -143,7 +146,8 @@ void for_each(Tuple &&tup, F &&f) {
 
 // =====================================================================================================================
 template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, std::enable_if_t<fmt::internal::is_tuple_like_v<TupleT>>> {
+struct formatter<TupleT, Char, 
+    typename std::enable_if<fmt::internal::is_tuple_like<TupleT>::value>::type> {
 
   fmt::formatting_tuple<Char> formatting;
 
@@ -177,10 +181,11 @@ struct formatter<TupleT, Char, std::enable_if_t<fmt::internal::is_tuple_like_v<T
 };
 
 template <typename RangeT, typename Char>
-struct formatter<RangeT, Char, std::enable_if_t<fmt::internal::is_range_v<RangeT>>> {
+struct formatter< RangeT, Char,
+    typename std::enable_if<fmt::internal::is_range<RangeT>::value>::type> {
 
-  static FMT_CONSTEXPR std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the range.
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
 
   fmt::formatting_range<Char> formatting;
 

From a70b48023f674526ec7acc535435adf646c2a950 Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sun, 13 May 2018 18:50:04 +0200
Subject: [PATCH 09/10] Moved range_length_limit to formatting_range. Added
 add_delimiter_spaces and add_prepostfix_space.

---
 include/fmt/ranges.h | 42 ++++++++++++++++++++++++++----------------
 test/ranges-test.cc  | 16 +++++++---------
 2 files changed, 33 insertions(+), 25 deletions(-)

diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index 02e69001..ae14907e 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -32,18 +32,22 @@ struct formatting_base {
 
 template <typename Char, typename Enable = void>
 struct formatting_range : formatting_base<Char> {
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
   Char prefix = '{';
   Char delimiter = ',';
   Char postfix = '}';
-  static FMT_CONSTEXPR_DECL const bool add_spaces = false;
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 template <typename Char, typename Enable = void>
 struct formatting_tuple : formatting_base<Char> {
-  Char prefix = '[';
+  Char prefix = '(';
   Char delimiter = ',';
-  Char postfix = ']';
-  static FMT_CONSTEXPR_DECL const bool add_spaces = false;
+  Char postfix = ')';
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 namespace internal {
@@ -92,10 +96,11 @@ 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 {};
+struct is_range_<T,typename std::conditional<
+                   false,
+                   conditional_helper<decltype(std::declval<T>().begin()),
+                                      decltype(std::declval<T>().end())>,
+                   void>::type> : std::true_type {};
 
 template <typename T>
 struct is_range {
@@ -162,16 +167,20 @@ struct formatter<TupleT, Char,
     std::size_t i = 0;
     internal::copy(formatting.prefix, out);
     internal::for_each(values, [&](const auto &v) {
-      if (i++ > 0) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
         internal::copy(formatting.delimiter, out);
       }
-      if (formatting.add_spaces) {
+      if (formatting.add_delimiter_spaces && i > 0) {
         format_to(out, " {}", v);
       } else {
         format_to(out, "{}", v);
       }
+      ++i;
     });
-    if (formatting.add_spaces) {
+    if (formatting.add_prepostfix_space) {
       *out++ = ' ';
     }
     internal::copy(formatting.postfix, out);
@@ -184,8 +193,6 @@ template <typename RangeT, typename Char>
 struct formatter< RangeT, Char,
     typename std::enable_if<fmt::internal::is_range<RangeT>::value>::type> {
 
-  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
 
   fmt::formatting_range<Char> formatting;
 
@@ -201,19 +208,22 @@ struct formatter< RangeT, Char,
     std::size_t i = 0;
     for (const auto &it : values) {
       if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
         internal::copy(formatting.delimiter, out);
       }
-      if (formatting.add_spaces) {
+      if (formatting.add_delimiter_spaces && i > 0) {
         format_to(out, " {}", it);
       } else {
         format_to(out, "{}", it);
       }
-      if (++i > range_length_limit) {
+      if (++i > formatting.range_length_limit) {
         format_to(out, " ... <other elements>");
         break;
       }
     }
-    if (formatting.add_spaces) {
+    if (formatting.add_prepostfix_space) {
       *out++ = ' ';
     }
     internal::copy(formatting.postfix, out);
diff --git a/test/ranges-test.cc b/test/ranges-test.cc
index 49d87080..1944173e 100644
--- a/test/ranges-test.cc
+++ b/test/ranges-test.cc
@@ -9,10 +9,6 @@
 // All Rights Reserved
 // {fmt} support for ranges, containers and types tuple interface.
 
-#ifdef WIN32
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
 #include "fmt/ranges.h"
 
 #include "gtest/gtest.h"
@@ -36,20 +32,21 @@ TEST(RangesTest, FormatVector2) {
 
 TEST(RangesTest, FormatMap) {
   std::map<std::string, int32_t> simap{{"one", 1}, {"two", 2}};
-  EXPECT_EQ("{[one,1],[two,2]}", fmt::format("{}", simap));
+  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));
+  EXPECT_EQ("(42,3.14159,this is tuple)", fmt::format("{}", tu1));
 }
 
+/// check if  'if constexpr' is supported.
 #if (__cplusplus > 201402L) || \
     (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
 
@@ -84,7 +81,8 @@ struct tuple_element<N, my_struct> {
 
 TEST(RangesTest, FormatStruct) {
   my_struct mst{13, "my struct"};
-  EXPECT_EQ("[13,my struct]", fmt::format("{}", mst));
+  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
+#endif  // (__cplusplus > 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >
+        // 201402L && _MSC_VER >= 1910)
\ No newline at end of file

From f65bcb8b08832076f73c572b0b19fec31c8320ea Mon Sep 17 00:00:00 2001
From: Remotion <remotion4d@gmail.com>
Date: Sun, 13 May 2018 18:58:25 +0200
Subject: [PATCH 10/10] Updated ranges-test.cc.

---
 test/ranges-test.cc | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/ranges-test.cc b/test/ranges-test.cc
index 1944173e..b7519747 100644
--- a/test/ranges-test.cc
+++ b/test/ranges-test.cc
@@ -21,29 +21,29 @@
 TEST(RangesTest, FormatVector) {
   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}};
   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));
+  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));
+  EXPECT_EQ("(42, 3.14159, this is tuple)", fmt::format("{}", tu1));
 }
 
 /// check if  'if constexpr' is supported.