flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-23 07:15:35 +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
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());
}
}

45
src/blackmisc/integersequence.h
View File

@@ -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

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.
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>>());
}

4
src/blackmisc/lockfree.h
View File

@@ -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()...);
}

8
src/blackmisc/metaclass.h
View File

@@ -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>

24
src/blackmisc/statusmessage.cpp
View File

@@ -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);
}
}
}