1/*!
2@file
3Defines `boost::hana::tuple`.
4
5Copyright Louis Dionne 2013-2022
6Copyright Jason Rice 2017
7Distributed under the Boost Software License, Version 1.0.
8(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
9 */
10
11#ifndef BOOST_HANA_TUPLE_HPP
12#define BOOST_HANA_TUPLE_HPP
13
14#include <boost/hana/fwd/tuple.hpp>
15
16#include <boost/hana/basic_tuple.hpp>
17#include <boost/hana/bool.hpp>
18#include <boost/hana/config.hpp>
19#include <boost/hana/detail/decay.hpp>
20#include <boost/hana/detail/fast_and.hpp>
21#include <boost/hana/detail/index_if.hpp>
22#include <boost/hana/detail/intrinsics.hpp>
23#include <boost/hana/detail/operators/adl.hpp>
24#include <boost/hana/detail/operators/comparable.hpp>
25#include <boost/hana/detail/operators/iterable.hpp>
26#include <boost/hana/detail/operators/monad.hpp>
27#include <boost/hana/detail/operators/orderable.hpp>
28#include <boost/hana/fwd/at.hpp>
29#include <boost/hana/fwd/core/make.hpp>
30#include <boost/hana/fwd/drop_front.hpp>
31#include <boost/hana/fwd/index_if.hpp>
32#include <boost/hana/fwd/is_empty.hpp>
33#include <boost/hana/fwd/length.hpp>
34#include <boost/hana/fwd/optional.hpp>
35#include <boost/hana/fwd/unpack.hpp>
36#include <boost/hana/type.hpp> // required by fwd decl of tuple_t
37
38#include <cstddef>
39#include <type_traits>
40#include <utility>
41
42
43namespace boost { namespace hana {
44 namespace detail {
45 template <typename Xs, typename Ys, std::size_t ...n>
46 constexpr void assign(Xs& xs, Ys&& ys, std::index_sequence<n...>) {
47 int sequence[] = {int{}, ((void)(
48 hana::at_c<n>(xs) = hana::at_c<n>(static_cast<Ys&&>(ys))
49 ), int{})...};
50 (void)sequence;
51 }
52
53 struct from_index_sequence_t { };
54
55 template <typename Tuple, typename ...Yn>
56 struct is_same_tuple : std::false_type { };
57
58 template <typename Tuple>
59 struct is_same_tuple<typename detail::decay<Tuple>::type, Tuple>
60 : std::true_type
61 { };
62
63 template <bool SameTuple, bool SameNumberOfElements, typename Tuple, typename ...Yn>
64 struct enable_tuple_variadic_ctor;
65
66 template <typename ...Xn, typename ...Yn>
67 struct enable_tuple_variadic_ctor<false, true, hana::tuple<Xn...>, Yn...>
68 : std::enable_if<
69 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value
70 >
71 { };
72 }
73
74 //////////////////////////////////////////////////////////////////////////
75 // tuple
76 //////////////////////////////////////////////////////////////////////////
77 template <>
78#ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE
79 struct __declspec(empty_bases) tuple<> final
80#else
81 struct tuple<> final
82#endif
83 : detail::operators::adl<tuple<>>
84 , detail::iterable_operators<tuple<>>
85 {
86 constexpr tuple() { }
87 using hana_tag = tuple_tag;
88 };
89
90 template <typename ...Xn>
91#ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE
92 struct __declspec(empty_bases) tuple final
93#else
94 struct tuple final
95#endif
96 : detail::operators::adl<tuple<Xn...>>
97 , detail::iterable_operators<tuple<Xn...>>
98 {
99 basic_tuple<Xn...> storage_;
100 using hana_tag = tuple_tag;
101
102 private:
103 template <typename Other, std::size_t ...n>
104 explicit constexpr tuple(detail::from_index_sequence_t, std::index_sequence<n...>, Other&& other)
105 : storage_(hana::at_c<n>(static_cast<Other&&>(other))...)
106 { }
107
108 public:
109 template <typename ...dummy, typename = typename std::enable_if<
110 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, dummy...)...>::value
111 >::type>
112 constexpr tuple()
113 : storage_()
114 { }
115
116 template <typename ...dummy, typename = typename std::enable_if<
117 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value
118 >::type>
119 constexpr tuple(Xn const& ...xn)
120 : storage_(xn...)
121 { }
122
123 template <typename ...Yn, typename = typename detail::enable_tuple_variadic_ctor<
124 detail::is_same_tuple<tuple, Yn...>::value,
125 sizeof...(Xn) == sizeof...(Yn), tuple, Yn...
126 >::type>
127 constexpr tuple(Yn&& ...yn)
128 : storage_(static_cast<Yn&&>(yn)...)
129 { }
130
131 template <typename ...Yn, typename = typename std::enable_if<
132 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn const&)...>::value
133 >::type>
134 constexpr tuple(tuple<Yn...> const& other)
135 : tuple(detail::from_index_sequence_t{},
136 std::make_index_sequence<sizeof...(Xn)>{},
137 other.storage_)
138 { }
139
140 template <typename ...Yn, typename = typename std::enable_if<
141 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value
142 >::type>
143 constexpr tuple(tuple<Yn...>&& other)
144 : tuple(detail::from_index_sequence_t{},
145 std::make_index_sequence<sizeof...(Xn)>{},
146 static_cast<tuple<Yn...>&&>(other).storage_)
147 { }
148
149 // The three following constructors are required to make sure that
150 // the tuple(Yn&&...) constructor is _not_ preferred over the copy
151 // constructor for unary tuples containing a type that is constructible
152 // from tuple<...>. See test/tuple/cnstr.trap.cpp
153 template <typename ...dummy, typename = typename std::enable_if<
154 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value
155 >::type>
156 constexpr tuple(tuple const& other)
157 : tuple(detail::from_index_sequence_t{},
158 std::make_index_sequence<sizeof...(Xn)>{},
159 other.storage_)
160 { }
161
162 template <typename ...dummy, typename = typename std::enable_if<
163 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value
164 >::type>
165 constexpr tuple(tuple& other)
166 : tuple(const_cast<tuple const&>(other))
167 { }
168
169 template <typename ...dummy, typename = typename std::enable_if<
170 detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn&&, dummy...)...>::value
171 >::type>
172 constexpr tuple(tuple&& other)
173 : tuple(detail::from_index_sequence_t{},
174 std::make_index_sequence<sizeof...(Xn)>{},
175 static_cast<tuple&&>(other).storage_)
176 { }
177
178
179 template <typename ...Yn, typename = typename std::enable_if<
180 detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn const&)...>::value
181 >::type>
182 constexpr tuple& operator=(tuple<Yn...> const& other) {
183 detail::assign(this->storage_, other.storage_,
184 std::make_index_sequence<sizeof...(Xn)>{});
185 return *this;
186 }
187
188 template <typename ...Yn, typename = typename std::enable_if<
189 detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn&&)...>::value
190 >::type>
191 constexpr tuple& operator=(tuple<Yn...>&& other) {
192 detail::assign(this->storage_, static_cast<tuple<Yn...>&&>(other).storage_,
193 std::make_index_sequence<sizeof...(Xn)>{});
194 return *this;
195 }
196 };
197
198 //////////////////////////////////////////////////////////////////////////
199 // Operators
200 //////////////////////////////////////////////////////////////////////////
201 namespace detail {
202 template <>
203 struct comparable_operators<tuple_tag> {
204 static constexpr bool value = true;
205 };
206 template <>
207 struct orderable_operators<tuple_tag> {
208 static constexpr bool value = true;
209 };
210 template <>
211 struct monad_operators<tuple_tag> {
212 static constexpr bool value = true;
213 };
214 }
215
216 //////////////////////////////////////////////////////////////////////////
217 // Foldable
218 //////////////////////////////////////////////////////////////////////////
219 template <>
220 struct unpack_impl<tuple_tag> {
221 template <typename F>
222 static constexpr decltype(auto) apply(tuple<>&&, F&& f)
223 { return static_cast<F&&>(f)(); }
224 template <typename F>
225 static constexpr decltype(auto) apply(tuple<>&, F&& f)
226 { return static_cast<F&&>(f)(); }
227 template <typename F>
228 static constexpr decltype(auto) apply(tuple<> const&, F&& f)
229 { return static_cast<F&&>(f)(); }
230
231 template <typename Xs, typename F>
232 static constexpr decltype(auto) apply(Xs&& xs, F&& f) {
233 return hana::unpack(static_cast<Xs&&>(xs).storage_, static_cast<F&&>(f));
234 }
235 };
236
237 template <>
238 struct length_impl<tuple_tag> {
239 template <typename ...Xs>
240 static constexpr auto apply(tuple<Xs...> const&)
241 { return hana::size_c<sizeof...(Xs)>; }
242 };
243
244 //////////////////////////////////////////////////////////////////////////
245 // Iterable
246 //////////////////////////////////////////////////////////////////////////
247 template <>
248 struct at_impl<tuple_tag> {
249 template <typename Xs, typename N>
250 static constexpr decltype(auto) apply(Xs&& xs, N const&) {
251 constexpr std::size_t index = N::value;
252 return hana::at_c<index>(static_cast<Xs&&>(xs).storage_);
253 }
254 };
255
256 template <>
257 struct drop_front_impl<tuple_tag> {
258 template <std::size_t N, typename Xs, std::size_t ...i>
259 static constexpr auto helper(Xs&& xs, std::index_sequence<i...>) {
260 return hana::make<tuple_tag>(hana::at_c<i+N>(static_cast<Xs&&>(xs))...);
261 }
262
263 template <typename Xs, typename N>
264 static constexpr auto apply(Xs&& xs, N const&) {
265 constexpr std::size_t len = decltype(hana::length(xs))::value;
266 return helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence<
267 (N::value < len) ? len - N::value : 0
268 >{});
269 }
270 };
271
272 template <>
273 struct is_empty_impl<tuple_tag> {
274 template <typename ...Xs>
275 static constexpr auto apply(tuple<Xs...> const&)
276 { return hana::bool_c<sizeof...(Xs) == 0>; }
277 };
278
279 // compile-time optimizations (to reduce the # of function instantiations)
280 template <std::size_t n, typename ...Xs>
281 constexpr decltype(auto) at_c(tuple<Xs...> const& xs) {
282 return hana::at_c<n>(xs.storage_);
283 }
284
285 template <std::size_t n, typename ...Xs>
286 constexpr decltype(auto) at_c(tuple<Xs...>& xs) {
287 return hana::at_c<n>(xs.storage_);
288 }
289
290 template <std::size_t n, typename ...Xs>
291 constexpr decltype(auto) at_c(tuple<Xs...>&& xs) {
292 return hana::at_c<n>(static_cast<tuple<Xs...>&&>(xs).storage_);
293 }
294
295 template <>
296 struct index_if_impl<tuple_tag> {
297 template <typename ...Xs, typename Pred>
298 static constexpr auto apply(tuple<Xs...> const&, Pred const&)
299 -> typename detail::index_if<Pred, Xs...>::type
300 { return {}; }
301 };
302
303 //////////////////////////////////////////////////////////////////////////
304 // Sequence
305 //////////////////////////////////////////////////////////////////////////
306 template <>
307 struct Sequence<tuple_tag> {
308 static constexpr bool value = true;
309 };
310
311 template <>
312 struct make_impl<tuple_tag> {
313 template <typename ...Xs>
314 static constexpr
315 tuple<typename detail::decay<Xs>::type...> apply(Xs&& ...xs)
316 { return {static_cast<Xs&&>(xs)...}; }
317 };
318}} // end namespace boost::hana
319
320#endif // !BOOST_HANA_TUPLE_HPP
321

source code of boost/libs/hana/include/boost/hana/tuple.hpp