From e8219efdde4c3f58aa429d17fb762e78d97fddfe Mon Sep 17 00:00:00 2001
From: Mathew Sutcliffe <oktal3700@gmail.com>
Date: Thu, 12 Oct 2017 23:50:15 +0100
Subject: [PATCH] Removed own implementation of std::index_sequence that was
 needed for GCC 4.9.

---
 src/blackmisc/algorithm.h       |  8 +++---
 src/blackmisc/integersequence.h | 45 ++++-----------------------------
 src/blackmisc/invoke.h          |  6 ++---
 src/blackmisc/lockfree.h        |  4 +--
 src/blackmisc/metaclass.h       |  8 +++---
 src/blackmisc/statusmessage.cpp | 24 +++++++++---------
 6 files changed, 30 insertions(+), 65 deletions(-)

diff --git a/src/blackmisc/algorithm.h b/src/blackmisc/algorithm.h
index 6f06939c5..8ea328b3c 100644
--- a/src/blackmisc/algorithm.h
+++ b/src/blackmisc/algorithm.h
@@ -145,7 +145,7 @@ namespace BlackMisc
     {
         //! \private
         template <typename T, typename F, size_t... Is>
-        void tupleForEachImpl(T &&tuple, F &&visitor, index_sequence<Is...>)
+        void tupleForEachImpl(T &&tuple, F &&visitor, std::index_sequence<Is...>)
         {
             // parameter pack swallow idiom
             static_cast<void>(std::initializer_list<int>
@@ -155,7 +155,7 @@ namespace BlackMisc
         }
         //! \private
         template <typename T, typename F, size_t... Is>
-        void tupleForEachPairImpl(T &&tuple, F &&visitor, index_sequence<Is...>)
+        void tupleForEachPairImpl(T &&tuple, F &&visitor, std::index_sequence<Is...>)
         {
             // parameter pack swallow idiom
             static_cast<void>(std::initializer_list<int>
@@ -171,7 +171,7 @@ namespace BlackMisc
     template <typename T, typename F>
     void tupleForEach(T &&tuple, F &&visitor)
     {
-        using seq = Private::make_index_sequence<std::tuple_size<std::decay_t<T>>::value>;
+        using seq = std::make_index_sequence<std::tuple_size<std::decay_t<T>>::value>;
         return Private::tupleForEachImpl(std::forward<T>(tuple), std::forward<F>(visitor), seq());
     }
 
@@ -181,7 +181,7 @@ namespace BlackMisc
     template <typename T, typename F>
     void tupleForEachPair(T &&tuple, F &&visitor)
     {
-        using seq = Private::make_index_sequence<std::tuple_size<std::decay_t<T>>::value / 2>;
+        using seq = std::make_index_sequence<std::tuple_size<std::decay_t<T>>::value / 2>;
         return Private::tupleForEachPairImpl(std::forward<T>(tuple), std::forward<F>(visitor), seq());
     }
 }
diff --git a/src/blackmisc/integersequence.h b/src/blackmisc/integersequence.h
index fc854dfa4..3950f2c20 100644
--- a/src/blackmisc/integersequence.h
+++ b/src/blackmisc/integersequence.h
@@ -16,11 +16,6 @@
 #include <type_traits>
 #include <cstddef>
 
-#if ! (defined(Q_CC_GNU) && __GNUC__ <= 4)
-//! \private
-#define BLACK_HAS_INTEGER_SEQUENCE
-#endif
-
 namespace BlackMisc
 {
 
@@ -28,36 +23,6 @@ namespace BlackMisc
     namespace Private
     {
 
-#ifdef BLACK_HAS_INTEGER_SEQUENCE
-        template <typename T, T... Is>
-        using integer_sequence = std::integer_sequence<T, Is...>;
-        template <typename T, T C>
-        using make_integer_sequence = std::make_integer_sequence<T, C>;
-#else // Our own implementation of std::integer_sequence (because not implemented by GCC 4.9)
-        template <typename T, T... Is>
-        struct integer_sequence
-        {
-            static const size_t size = sizeof...(Is);
-            typedef std::tuple<std::integral_constant<T, Is>...> tuple_type;
-        };
-        template <typename T, T I, T C, T... Is>
-        struct GenSequence
-        {
-            typedef typename GenSequence<T, I + 1, C, Is..., I>::type type;
-        };
-        template <typename T, T C, T... Is>
-        struct GenSequence<T, C, C, Is...>
-        {
-            typedef integer_sequence<T, Is...> type;
-        };
-        template <typename T, T C>
-        using make_integer_sequence = typename GenSequence<T, 0, C>::type;
-#endif // ! BLACK_HAS_INTEGER_SEQUENCE
-        template <size_t... Is>
-        using index_sequence = integer_sequence<size_t, Is...>;
-        template <size_t C>
-        using make_index_sequence = make_integer_sequence<size_t, C>;
-
         // Remove elements from an index_sequence for which a pack parameter fails to satisfy a given predicate.
         template <typename, typename T, bool...>
         struct MaskSequenceImpl
@@ -66,19 +31,19 @@ namespace BlackMisc
         };
 
         template <size_t I, size_t... Is, bool... Mask, size_t... Js>
-        struct MaskSequenceImpl<index_sequence<I, Is...>, index_sequence<Js...>, true, Mask...>
+        struct MaskSequenceImpl<std::index_sequence<I, Is...>, std::index_sequence<Js...>, true, Mask...>
         {
-            using type = typename MaskSequenceImpl<index_sequence<Is...>, index_sequence<Js..., I>, Mask...>::type;
+            using type = typename MaskSequenceImpl<std::index_sequence<Is...>, std::index_sequence<Js..., I>, Mask...>::type;
         };
 
         template <size_t I, size_t... Is, bool... Mask, size_t... Js>
-        struct MaskSequenceImpl<index_sequence<I, Is...>, index_sequence<Js...>, false, Mask...>
+        struct MaskSequenceImpl<std::index_sequence<I, Is...>, std::index_sequence<Js...>, false, Mask...>
         {
-            using type = typename MaskSequenceImpl<index_sequence<Is...>, index_sequence<Js...>, Mask...>::type;
+            using type = typename MaskSequenceImpl<std::index_sequence<Is...>, std::index_sequence<Js...>, Mask...>::type;
         };
 
         template <typename Seq, bool... Mask>
-        using MaskSequence = typename MaskSequenceImpl<Seq, Private::index_sequence<>, Mask...>::type;
+        using MaskSequence = typename MaskSequenceImpl<Seq, std::index_sequence<>, Mask...>::type;
 
     } // namespace Private
     //! \endcond
diff --git a/src/blackmisc/invoke.h b/src/blackmisc/invoke.h
index f19759f70..7cf5f6806 100644
--- a/src/blackmisc/invoke.h
+++ b/src/blackmisc/invoke.h
@@ -41,13 +41,13 @@ namespace BlackMisc
 
         // Like invoke() but ignores the first argument if callable is not a member function. For uniform calling of callables with slot semantics.
         template <typename F, typename T, typename U, size_t... Is>
-        decltype(auto) invokeSlotImpl(F ptr, T *object, U tuple, index_sequence<Is...>, std::true_type)
+        decltype(auto) invokeSlotImpl(F ptr, T *object, U tuple, std::index_sequence<Is...>, std::true_type)
         {
             Q_UNUSED(tuple); // in case the pack expansion is empty
             return (object->*ptr)(std::forward<std::tuple_element_t<Is, U>>(std::get<Is>(tuple))...);
         }
         template <typename F, typename T, typename U, size_t... Is>
-        decltype(auto) invokeSlotImpl(F &&func, T *, U tuple, index_sequence<Is...>, std::false_type)
+        decltype(auto) invokeSlotImpl(F &&func, T *, U tuple, std::index_sequence<Is...>, std::false_type)
         {
             Q_UNUSED(tuple); // in case the pack expansion is empty
             return std::forward<F>(func)(std::forward<std::tuple_element_t<Is, U>>(std::get<Is>(tuple))...);
@@ -55,7 +55,7 @@ namespace BlackMisc
         template <typename F, typename T, typename... Ts>
         decltype(auto) invokeSlot(F &&func, T *object, Ts &&... args)
         {
-            using seq = MaskSequence<make_index_sequence<sizeof...(Ts)>, ! TIsQPrivateSignal<std::decay_t<Ts>>::value...>;
+            using seq = MaskSequence<std::make_index_sequence<sizeof...(Ts)>, ! TIsQPrivateSignal<std::decay_t<Ts>>::value...>;
             return invokeSlotImpl(std::forward<F>(func), object, std::forward_as_tuple(std::forward<Ts>(args)...), seq(), std::is_member_pointer<std::decay_t<F>>());
         }
 
diff --git a/src/blackmisc/lockfree.h b/src/blackmisc/lockfree.h
index 15f9fa621..0bd91ee5c 100644
--- a/src/blackmisc/lockfree.h
+++ b/src/blackmisc/lockfree.h
@@ -293,12 +293,12 @@ namespace BlackMisc
         template <typename F>
         auto operator ()(F &&function) &&
         {
-            return call(std::forward<F>(function), Private::make_index_sequence<sizeof...(Ts)>());
+            return call(std::forward<F>(function), std::make_index_sequence<sizeof...(Ts)>());
         }
 
     private:
         template <typename F, size_t... Is>
-        auto call(F &&function, Private::index_sequence<Is...>)
+        auto call(F &&function, std::index_sequence<Is...>)
         {
             return std::forward<F>(function)(std::get<Is>(m_tup).get()...);
         }
diff --git a/src/blackmisc/metaclass.h b/src/blackmisc/metaclass.h
index d9e9a055a..8a49a39f7 100644
--- a/src/blackmisc/metaclass.h
+++ b/src/blackmisc/metaclass.h
@@ -270,10 +270,10 @@ namespace BlackMisc
 
     private:
         template <bool... Mask>
-        using MaskSequence = Private::MaskSequence<Private::index_sequence<Is...>, Mask...>;
+        using MaskSequence = Private::MaskSequence<std::index_sequence<Is...>, Mask...>;
 
         template <size_t... Js>
-        static auto filter(Private::index_sequence<Js...>) { return CMetaClassIntrospector<T, MetaClass, Js...>(); }
+        static auto filter(std::index_sequence<Js...>) { return CMetaClassIntrospector<T, MetaClass, Js...>(); }
 
         template <size_t I>
         using index = std::integral_constant<size_t, I>;
@@ -287,7 +287,7 @@ namespace BlackMisc
         struct CMetaClassAccessor
         {
             template <typename T, size_t... Is>
-            static auto getIntrospector(index_sequence<Is...>)
+            static auto getIntrospector(std::index_sequence<Is...>)
             {
                 return CMetaClassIntrospector<T, typename T::MetaClass, Is...>();
             }
@@ -295,7 +295,7 @@ namespace BlackMisc
             template <typename T>
             static auto getIntrospector()
             {
-                return getIntrospector<T>(Private::make_index_sequence<T::MetaClass::getMemberList().c_size>());
+                return getIntrospector<T>(std::make_index_sequence<T::MetaClass::getMemberList().c_size>());
             }
 
             template <typename T>
diff --git a/src/blackmisc/statusmessage.cpp b/src/blackmisc/statusmessage.cpp
index f27e95dbb..3a13e2033 100644
--- a/src/blackmisc/statusmessage.cpp
+++ b/src/blackmisc/statusmessage.cpp
@@ -23,8 +23,8 @@ namespace BlackMisc
     {
         namespace
         {
-            template <size_t... Is> QString arg(index_sequence<Is...>, const QString &format, const QStringList &args) { return format.arg(args[Is]...); }
-            QString arg(index_sequence<>, const QString &format, const QStringList &) { return format; }
+            template <size_t... Is> QString arg(std::index_sequence<Is...>, const QString &format, const QStringList &args) { return format.arg(args[Is]...); }
+            QString arg(std::index_sequence<>, const QString &format, const QStringList &) { return format; }
         }
 
         QString arg(const QString &format, const QStringList &args)
@@ -37,17 +37,17 @@ namespace BlackMisc
             {
                 switch (args.size())
                 {
-                case 0: return arg(Private::make_index_sequence<0>(), format, args);
-                case 1: return arg(Private::make_index_sequence<1>(), format, args);
-                case 2: return arg(Private::make_index_sequence<2>(), format, args);
-                case 3: return arg(Private::make_index_sequence<3>(), format, args);
-                case 4: return arg(Private::make_index_sequence<4>(), format, args);
-                case 5: return arg(Private::make_index_sequence<5>(), format, args);
-                case 6: return arg(Private::make_index_sequence<6>(), format, args);
-                case 7: return arg(Private::make_index_sequence<7>(), format, args);
-                case 8: return arg(Private::make_index_sequence<8>(), format, args);
+                case 0: return arg(std::make_index_sequence<0>(), format, args);
+                case 1: return arg(std::make_index_sequence<1>(), format, args);
+                case 2: return arg(std::make_index_sequence<2>(), format, args);
+                case 3: return arg(std::make_index_sequence<3>(), format, args);
+                case 4: return arg(std::make_index_sequence<4>(), format, args);
+                case 5: return arg(std::make_index_sequence<5>(), format, args);
+                case 6: return arg(std::make_index_sequence<6>(), format, args);
+                case 7: return arg(std::make_index_sequence<7>(), format, args);
+                case 8: return arg(std::make_index_sequence<8>(), format, args);
                 default: qWarning("Too many arguments to BlackMisc::Private::arg"); // intentional fall-through
-                case 9: return arg(Private::make_index_sequence<9>(), format, args);
+                case 9: return arg(std::make_index_sequence<9>(), format, args);
                 }
             }
         }