flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-04-21 04:45:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Removed own implementation of std::index_sequence that was needed for GCC 4.9.

Browse Source
This commit is contained in:
Mathew Sutcliffe
2017-10-12 23:50:15 +01:00
parent 0b67466480
commit e8219efdde
6 changed files with 30 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/blackmisc/algorithm.h
View File

@@ -145,7 +145,7 @@ namespace BlackMisc
{ {
//! \private //! \private
template <typename T, typename F, size_t... Is> 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 // parameter pack swallow idiom
static_cast<void>(std::initializer_list<int> static_cast<void>(std::initializer_list<int>
@@ -155,7 +155,7 @@ namespace BlackMisc
} }
//! \private //! \private
template <typename T, typename F, size_t... Is> 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 // parameter pack swallow idiom
static_cast<void>(std::initializer_list<int> static_cast<void>(std::initializer_list<int>
@@ -171,7 +171,7 @@ namespace BlackMisc
template <typename T, typename F> template <typename T, typename F>
void tupleForEach(T &&tuple, F &&visitor) 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()); return Private::tupleForEachImpl(std::forward<T>(tuple), std::forward<F>(visitor), seq());
} }
@@ -181,7 +181,7 @@ namespace BlackMisc
template <typename T, typename F> template <typename T, typename F>
void tupleForEachPair(T &&tuple, F &&visitor) 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()); return Private::tupleForEachPairImpl(std::forward<T>(tuple), std::forward<F>(visitor), seq());
} }
} }

45
src/blackmisc/integersequence.h
View File

@@ -16,11 +16,6 @@
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#if ! (defined(Q_CC_GNU) && __GNUC__ <= 4)
//! \private
#define BLACK_HAS_INTEGER_SEQUENCE
#endif
namespace BlackMisc namespace BlackMisc
{ {
@@ -28,36 +23,6 @@ namespace BlackMisc
namespace Private 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. // Remove elements from an index_sequence for which a pack parameter fails to satisfy a given predicate.
template <typename, typename T, bool...> template <typename, typename T, bool...>
struct MaskSequenceImpl struct MaskSequenceImpl
@@ -66,19 +31,19 @@ namespace BlackMisc
}; };
template <size_t I, size_t... Is, bool... Mask, size_t... Js> 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> 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> 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 } // namespace Private
//! \endcond //! \endcond

6
src/blackmisc/invoke.h
View File

@@ -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. // 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> 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 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))...); 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> 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 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))...); 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> template <typename F, typename T, typename... Ts>
decltype(auto) invokeSlot(F &&func, T *object, Ts &&... args) 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>>()); return invokeSlotImpl(std::forward<F>(func), object, std::forward_as_tuple(std::forward<Ts>(args)...), seq(), std::is_member_pointer<std::decay_t<F>>());
} }

4
src/blackmisc/lockfree.h
View File

@@ -293,12 +293,12 @@ namespace BlackMisc
template <typename F> template <typename F>
auto operator ()(F &&function) && 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: private:
template <typename F, size_t... Is> 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()...); return std::forward<F>(function)(std::get<Is>(m_tup).get()...);
} }

8
src/blackmisc/metaclass.h
View File

@@ -270,10 +270,10 @@ namespace BlackMisc
private: private:
template <bool... Mask> 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> 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> template <size_t I>
using index = std::integral_constant<size_t, I>; using index = std::integral_constant<size_t, I>;
@@ -287,7 +287,7 @@ namespace BlackMisc
struct CMetaClassAccessor struct CMetaClassAccessor
{ {
template <typename T, size_t... Is> 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...>(); return CMetaClassIntrospector<T, typename T::MetaClass, Is...>();
} }
@@ -295,7 +295,7 @@ namespace BlackMisc
template <typename T> template <typename T>
static auto getIntrospector() 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> template <typename T>

24
src/blackmisc/statusmessage.cpp
View File

@@ -23,8 +23,8 @@ namespace BlackMisc
{ {
namespace namespace
{ {
template <size_t... Is> QString arg(index_sequence<Is...>, const QString &format, const QStringList &args) { return format.arg(args[Is]...); } template <size_t... Is> QString arg(std::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; } QString arg(std::index_sequence<>, const QString &format, const QStringList &) { return format; }
} }
QString arg(const QString &format, const QStringList &args) QString arg(const QString &format, const QStringList &args)
@@ -37,17 +37,17 @@ namespace BlackMisc
{ {
switch (args.size()) switch (args.size())
{ {
case 0: return arg(Private::make_index_sequence<0>(), format, args); case 0: return arg(std::make_index_sequence<0>(), format, args);
case 1: return arg(Private::make_index_sequence<1>(), format, args); case 1: return arg(std::make_index_sequence<1>(), format, args);
case 2: return arg(Private::make_index_sequence<2>(), format, args); case 2: return arg(std::make_index_sequence<2>(), format, args);
case 3: return arg(Private::make_index_sequence<3>(), format, args); case 3: return arg(std::make_index_sequence<3>(), format, args);
case 4: return arg(Private::make_index_sequence<4>(), format, args); case 4: return arg(std::make_index_sequence<4>(), format, args);
case 5: return arg(Private::make_index_sequence<5>(), format, args); case 5: return arg(std::make_index_sequence<5>(), format, args);
case 6: return arg(Private::make_index_sequence<6>(), format, args); case 6: return arg(std::make_index_sequence<6>(), format, args);
case 7: return arg(Private::make_index_sequence<7>(), format, args); case 7: return arg(std::make_index_sequence<7>(), format, args);
case 8: return arg(Private::make_index_sequence<8>(), 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 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);
} }
} }
} }