From 82a8ea390253df9d83012964af06310992e4c316 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Sat, 11 Jul 2015 17:26:41 +0100
Subject: [PATCH] SFINAE friendly ToString and expansion of any tuple-like type
 in format

---
 octa/format.hh | 46 +++++++++++++++++++++++++++++--------
 octa/string.hh | 62 ++++++++++++++++++++++++++++++--------------------
 octa/tuple.hh  |  4 ++--
 3 files changed, 75 insertions(+), 37 deletions(-)

diff --git a/octa/format.hh b/octa/format.hh
index f92d4ef..af8661f 100644
--- a/octa/format.hh
+++ b/octa/format.hh
@@ -14,6 +14,7 @@
 #include "octa/algorithm.hh"
 #include "octa/string.hh"
 #include "octa/utility.hh"
+#include "octa/internal/tuple.hh"
 
 namespace octa {
 
@@ -458,21 +459,46 @@ namespace detail {
     template<typename T>
     using FmtRangeTest = decltype(test_fmt_range<T>(0));
 
+    template<Size I>
+    struct FmtTupleUnpacker {
+        template<typename R, typename T, typename ...A>
+        static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc,
+                                     const char *fmt, const T &item,
+                                     const A &...args) {
+            return FmtTupleUnpacker<I - 1>::unpack(writer, fmtn, esc, fmt,
+                item, get<I - 1>(item), args...);
+        }
+    };
+
+    template<>
+    struct FmtTupleUnpacker<0> {
+        template<typename R, typename T, typename ...A>
+        static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc,
+                                     const char *fmt, const T &,
+                                     const A &...args) {
+            return format_impl(writer, fmtn, esc, fmt, args...);
+        }
+    };
+
     template<typename R, typename T>
     inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc, bool,
-                                const char *fmt, const T &item) {
+                                const char *fmt, const T &item,
+                                EnableIf<!IsTupleLike<T>::value, bool>
+                                    = true) {
         return format_impl(writer, fmtn, esc, fmt, item);
     }
 
-    template<typename R, typename T, typename U>
+    template<typename R, typename T>
     inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc,
                                 bool expandval, const char *fmt,
-                                const Pair<T, U> &pair) {
+                                const T &item,
+                                EnableIf<IsTupleLike<T>::value, bool>
+                                    = true) {
         if (expandval) {
-            return format_impl(writer, fmtn, esc, fmt, pair.first,
-                pair.second);
+            return FmtTupleUnpacker<TupleSize<T>::value>::unpack(writer,
+                fmtn, esc, fmt, item);
         }
-        return format_impl(writer, fmtn, esc, fmt, pair);
+        return format_impl(writer, fmtn, esc, fmt, item);
     }
 
     template<typename R, typename T>
@@ -515,9 +541,8 @@ namespace detail {
         return -1;
     }
 
-    template<typename T,
-        typename = decltype(octa::to_string(declval<T>()))
-    > static True test_fmt_tostr(int);
+    template<typename T>
+    static True test_fmt_tostr(decltype(octa::to_string(declval<T>())) *);
     template<typename> static False test_fmt_tostr(...);
 
     template<typename T>
@@ -756,7 +781,8 @@ namespace detail {
         /* generic failure case */
         template<typename R, typename T>
         Ptrdiff write(R &, bool, const T &, EnableIf<
-            !IsArithmetic<T>::value && !FmtTostrTest<T>::value, bool
+            !IsArithmetic<T>::value && !FmtTostrTest<T>::value &&
+            !FmtTofmtTest<T, FmtWriteRange<R>>::value, bool
         > = true) {
             assert(false && "value cannot be formatted");
             return -1;
diff --git a/octa/string.hh b/octa/string.hh
index 25cd68b..f278a9d 100644
--- a/octa/string.hh
+++ b/octa/string.hh
@@ -485,24 +485,24 @@ namespace detail {
         template<typename U> static  int test(...);
         static constexpr bool value = (sizeof(test<T>(0)) == sizeof(char));
     };
+
+    template<typename T>
+    static True test_iterable(decltype(octa::iter(declval<T>())) *);
+    template<typename> static False test_iterable(...);
+
+    template<typename T>
+    using IterableTest = decltype(test_iterable<T>(0));
 }
 
-template<typename T> struct ToString {
+template<typename T, typename = void>
+struct ToString;
+
+template<typename T>
+struct ToString<T, EnableIf<detail::IterableTest<T>::value>> {
     using Argument = T;
     using Result = String;
 
-    template<typename U>
-    static String to_str(const U &v,
-        EnableIf<detail::ToStringTest<U>::value, bool> = true
-    ) {
-        return v.to_string();
-    }
-
-    template<typename U>
-    static String to_str(const U &v,
-        EnableIf<!detail::ToStringTest<U>::value &&
-            !IsScalar<U>::value, bool> = true
-    ) {
+    String operator()(const T &v) const {
         String ret("{");
         ret += concat(octa::iter(v), ", ", ToString<
             RemoveCv<RemoveReference<
@@ -512,20 +512,34 @@ template<typename T> struct ToString {
         ret += "}";
         return ret;
     }
+};
 
-    template<typename U>
-    static String to_str(const U &v,
-        EnableIf<!detail::ToStringTest<U>::value &&
-            IsScalar<U>::value, bool> = true
-    ) {
-        return ToString<U>()(v);
-    }
+template<typename T>
+struct ToString<T, EnableIf<IsScalar<T>::value>> {
+    using Argument = T;
+    using Result = String;
 
     String operator()(const T &v) const {
-        return to_str(v);
+       return ToString<T>()(v);
     }
 };
 
+template<typename T>
+struct ToString<T, EnableIf<detail::ToStringTest<T>::value>> {
+    using Argument = T;
+    using Result = String;
+
+    String operator()(const T &v) const {
+        return v.to_string();
+    }
+};
+
+template<typename T> struct ToString<const T, EnableIf<
+    !detail::IterableTest<T>::value &&
+    !detail::ToStringTest<T>::value &&
+    !IsScalar<T>::value
+>>: ToString<T> {};
+
 namespace detail {
     template<typename T>
     void str_printf(Vector<char> *s, const char *fmt, T v) {
@@ -637,10 +651,8 @@ template<typename T, typename U> struct ToString<Pair<T, U>> {
     }
 };
 
-template<typename T> struct ToString<const T>: ToString<T> {};
-
-template<typename T, typename = decltype(ToString<T>()(declval<T>()))>
-String to_string(const T &v) {
+template<typename T>
+typename ToString<T>::Result to_string(const T &v) {
     return ToString<T>()(v);
 }
 
diff --git a/octa/tuple.hh b/octa/tuple.hh
index cfcc912..b4e72a9 100644
--- a/octa/tuple.hh
+++ b/octa/tuple.hh
@@ -277,10 +277,10 @@ class Tuple {
     friend TupleElement<I, Tuple<T...>> &get(Tuple<T...> &);
 
     template<Size I, typename ...T>
-    friend TupleElement<I, Tuple<T...>> &get(const Tuple<T...> &);
+    friend const TupleElement<I, Tuple<T...>> &get(const Tuple<T...> &);
 
     template<Size I, typename ...T>
-    friend TupleElement<I, Tuple<T...>> &get(Tuple<T...> &&);
+    friend TupleElement<I, Tuple<T...>> &&get(Tuple<T...> &&);
 
 public:
     template<bool D = true, typename = EnableIf<