1 | /**************************************************************************** |
---|---|

2 | ** |

3 | ** Copyright (C) 2018 The Qt Company Ltd. |

4 | ** Contact: https://www.qt.io/licensing/ |

5 | ** |

6 | ** This file is part of the QtCore module of the Qt Toolkit. |

7 | ** |

8 | ** $QT_BEGIN_LICENSE:LGPL$ |

9 | ** Commercial License Usage |

10 | ** Licensees holding valid commercial Qt licenses may use this file in |

11 | ** accordance with the commercial license agreement provided with the |

12 | ** Software or, alternatively, in accordance with the terms contained in |

13 | ** a written agreement between you and The Qt Company. For licensing terms |

14 | ** and conditions see https://www.qt.io/terms-conditions. For further |

15 | ** information use the contact form at https://www.qt.io/contact-us. |

16 | ** |

17 | ** GNU Lesser General Public License Usage |

18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |

19 | ** General Public License version 3 as published by the Free Software |

20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |

21 | ** packaging of this file. Please review the following information to |

22 | ** ensure the GNU Lesser General Public License version 3 requirements |

23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |

24 | ** |

25 | ** GNU General Public License Usage |

26 | ** Alternatively, this file may be used under the terms of the GNU |

27 | ** General Public License version 2.0 or (at your option) the GNU General |

28 | ** Public license version 3 or any later version approved by the KDE Free |

29 | ** Qt Foundation. The licenses are as published by the Free Software |

30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |

31 | ** included in the packaging of this file. Please review the following |

32 | ** information to ensure the GNU General Public License requirements will |

33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |

34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |

35 | ** |

36 | ** $QT_END_LICENSE$ |

37 | ** |

38 | ****************************************************************************/ |

39 | |

40 | #ifndef QMAKEARRAY_P_H |

41 | #define QMAKEARRAY_P_H |

42 | |

43 | // |

44 | // W A R N I N G |

45 | // ------------- |

46 | // |

47 | // This file is not part of the Qt API. It exists purely as an |

48 | // implementation detail. This header file may change from version to |

49 | // version without notice, or even be removed. |

50 | // |

51 | // We mean it. |

52 | // |

53 | |

54 | #include "QtCore/qglobal.h" |

55 | |

56 | #include <array> |

57 | #include <type_traits> |

58 | #include <utility> |

59 | |

60 | QT_BEGIN_NAMESPACE |

61 | |

62 | namespace QtPrivate { |

63 | template<typename T> |

64 | constexpr T&& Forward(typename std::remove_reference<T>::type& t) noexcept |

65 | { |

66 | return static_cast<T&&>(t); |

67 | } |

68 | |

69 | template<typename T> |

70 | constexpr T&& Forward(typename std::remove_reference<T>::type&& t) noexcept |

71 | { |

72 | static_assert(!std::is_lvalue_reference<T>::value, |

73 | "template argument substituting T is an lvalue reference type"); |

74 | return static_cast<T&&>(t); |

75 | } |

76 | |

77 | template <typename ManualType, typename ...> |

78 | struct ArrayTypeHelper |

79 | { |

80 | using type = ManualType; |

81 | }; |

82 | |

83 | template <typename ... Types> |

84 | struct ArrayTypeHelper<void, Types...> : std::common_type<Types...> { }; |

85 | |

86 | template <typename ManualType, typename... Types> |

87 | using ArrayType = std::array<typename ArrayTypeHelper<ManualType, Types...>::type, |

88 | sizeof...(Types)>; |

89 | |

90 | template<typename ... Values> |

91 | struct QuickSortData { }; |

92 | |

93 | template <template <typename> class Predicate, |

94 | typename ... Values> |

95 | struct QuickSortFilter; |

96 | |

97 | template <typename ... Right, typename ... Left> |

98 | constexpr QuickSortData<Right..., Left...> quickSortConcat( |

99 | QuickSortData<Right...>, QuickSortData<Left...>) noexcept; |

100 | |

101 | template<typename ... Right, typename Middle, typename ... Left> |

102 | constexpr QuickSortData<Right..., Middle, Left...> quickSortConcat( |

103 | QuickSortData<Right...>, |

104 | QuickSortData<Middle>, |

105 | QuickSortData<Left...>) noexcept; |

106 | |

107 | template <template <typename> class Predicate, |

108 | typename Head, typename ... Tail> |

109 | struct QuickSortFilter<Predicate, QuickSortData<Head, Tail...>> |

110 | { |

111 | using TailFilteredData = typename QuickSortFilter< |

112 | Predicate, QuickSortData<Tail...>>::Type; |

113 | |

114 | using Type = typename std::conditional< |

115 | Predicate<Head>::value, |

116 | decltype(quickSortConcat(QuickSortData<Head> {}, TailFilteredData{})), |

117 | TailFilteredData>::type; |

118 | }; |

119 | |

120 | template <template <typename> class Predicate> |

121 | struct QuickSortFilter<Predicate, QuickSortData<>> |

122 | { |

123 | using Type = QuickSortData<>; |

124 | }; |

125 | |

126 | template <typename ... Values> |

127 | struct QuickSort; |

128 | |

129 | template <typename Pivot, typename ... Values> |

130 | struct QuickSort<QuickSortData<Pivot, Values...>> |

131 | { |

132 | template <typename Left> |

133 | struct LessThan { |

134 | static constexpr const bool value = Left::data() <= Pivot::data(); |

135 | }; |

136 | |

137 | template <typename Left> |

138 | struct MoreThan { |

139 | static constexpr const bool value = !(Left::data() <= Pivot::data()); |

140 | }; |

141 | |

142 | using LeftSide = typename QuickSortFilter<LessThan, QuickSortData<Values...>>::Type; |

143 | using RightSide = typename QuickSortFilter<MoreThan, QuickSortData<Values...>>::Type; |

144 | |

145 | using LeftQS = typename QuickSort<LeftSide>::Type; |

146 | using RightQS = typename QuickSort<RightSide>::Type; |

147 | |

148 | using Type = decltype(quickSortConcat(LeftQS{}, QuickSortData<Pivot> {}, RightQS{})); |

149 | |

150 | }; |

151 | |

152 | template <> |

153 | struct QuickSort<QuickSortData<>> |

154 | { |

155 | using Type = QuickSortData<>; |

156 | }; |

157 | } // namespace QtPrivate |

158 | |

159 | template <typename ManualType = void, typename ... Types> |

160 | constexpr QtPrivate::ArrayType<ManualType, Types...> qMakeArray(Types && ... t) noexcept |

161 | { |

162 | return {{QtPrivate::Forward<typename QtPrivate::ArrayType<ManualType, Types...>::value_type>(t)...}}; |

163 | } |

164 | |

165 | template<typename ... Values> |

166 | struct QSortedData { |

167 | using Data = typename QtPrivate::QuickSort<typename QtPrivate::QuickSortData<Values...>>::Type; |

168 | }; |

169 | |

170 | template<typename ... Values> |

171 | constexpr auto qMakeArray(QtPrivate::QuickSortData<Values...>) noexcept -> decltype(qMakeArray(Values::data()...)) |

172 | { |

173 | return qMakeArray(Values::data() ...); |

174 | } |

175 | |

176 | |

177 | QT_END_NAMESPACE |

178 | |

179 | #endif // QMAKEARRAY_P_H |

180 |