1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*!
@file
Defines `boost::hana::arg`.
@copyright Louis Dionne 2013-2016
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_HANA_FUNCTIONAL_ARG_HPP
#define BOOST_HANA_FUNCTIONAL_ARG_HPP
#include <boost/hana/config.hpp>
#include <cstddef>
#include <type_traits>
BOOST_HANA_NAMESPACE_BEGIN
//! @ingroup group-functional
//! Return the `n`th passed argument.
//!
//! Specifically, `arg<n>(x1, ..., xn, ..., xm)` is equivalent to `xn`.
//! Note that indexing starts at 1, so `arg<1>` returns the 1st argument,
//! `arg<2>` the 2nd and so on. Using `arg<0>` is an error. Passing
//! less than `n` arguments to `arg<n>` is also an error.
//!
//!
//! @tparam n
//! An unsigned integer representing the argument to return. `n` must be
//! positive (meaning nonzero).
//!
//! @param x1, ..., xm
//! A variadic pack of arguments from which the `n`th one is returned.
//!
//!
//! @internal
//! ### Discussion: could `n` be dynamic?
//! We could have chosen `arg` to be used like `arg(n)(x...)` instead of
//! `arg<n>(x...)`. Provided all the arguments were of the same type, it
//! would then be possible for `n` to only be known at runtime. However,
//! we would then lose the ability to assert the in-boundedness of `n`
//! statically.
//!
//! ### Rationale for `n` being a non-type template parameter
//! I claim that the only interesting use case is with a compile-time
//! `n`, which means that the usage would become `arg(int_<n>)(x...)`,
//! which is more cumbersome to write than `arg<n>(x...)`. This is open
//! for discussion.
//! @endinternal
//!
//! ### Example
//! @include example/functional/arg.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
template <std::size_t n>
constexpr auto arg = [](auto&& x1, ..., auto&& xm) -> decltype(auto) {
return forwarded(xn);
};
#else
template <std::size_t n, typename = void>
struct arg_t;
template <>
struct arg_t<1> {
template <typename X1, typename ...Xn>
constexpr X1 operator()(X1&& x1, Xn&& ...) const
{ return static_cast<X1&&>(x1); }
};
template <>
struct arg_t<2> {
template <typename X1, typename X2, typename ...Xn>
constexpr X2 operator()(X1&&, X2&& x2, Xn&& ...) const
{ return static_cast<X2&&>(x2); }
};
template <>
struct arg_t<3> {
template <typename X1, typename X2, typename X3, typename ...Xn>
constexpr X3 operator()(X1&&, X2&&, X3&& x3, Xn&& ...) const
{ return static_cast<X3&&>(x3); }
};
template <>
struct arg_t<4> {
template <typename X1, typename X2, typename X3, typename X4, typename ...Xn>
constexpr X4 operator()(X1&&, X2&&, X3&&, X4&& x4, Xn&& ...) const
{ return static_cast<X4&&>(x4); }
};
template <>
struct arg_t<5> {
template <typename X1, typename X2, typename X3, typename X4,
typename X5, typename ...Xn>
constexpr X5 operator()(X1&&, X2&&, X3&&, X4&&, X5&& x5, Xn&& ...) const
{ return static_cast<X5&&>(x5); }
};
template <std::size_t n, typename>
struct arg_t {
static_assert(n > 0,
"invalid usage of boost::hana::arg<n> with n == 0");
template <typename X1, typename X2, typename X3, typename X4,
typename X5, typename ...Xn>
constexpr decltype(auto)
operator()(X1&&, X2&&, X3&&, X4&&, X5&&, Xn&& ...xn) const {
static_assert(sizeof...(xn) >= n - 5,
"invalid usage of boost::hana::arg<n> with too few arguments");
// Since compilers will typically try to continue for a bit after
// an error/static assertion, we must avoid sending the compiler
// in a very long computation if n == 0.
return arg_t<n == 0 ? 1 : n - 5>{}(static_cast<Xn&&>(xn)...);
}
};
template <std::size_t n>
struct arg_t<n, std::enable_if_t<(n > 25)>> {
template <
typename X1, typename X2, typename X3, typename X4, typename X5,
typename X6, typename X7, typename X8, typename X9, typename X10,
typename X11, typename X12, typename X13, typename X14, typename X15,
typename X16, typename X17, typename X18, typename X19, typename X20,
typename X21, typename X22, typename X23, typename X24, typename X25,
typename ...Xn>
constexpr decltype(auto)
operator()(X1&&, X2&&, X3&&, X4&&, X5&&,
X6&&, X7&&, X8&&, X9&&, X10&&,
X11&&, X12&&, X13&&, X14&&, X15&&,
X16&&, X17&&, X18&&, X19&&, X20&&,
X21&&, X22&&, X23&&, X24&&, X25&&, Xn&& ...xn) const
{ return arg_t<n - 25>{}(static_cast<Xn&&>(xn)...); }
};
template <std::size_t n>
constexpr arg_t<n> arg{};
#endif
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_FUNCTIONAL_ARG_HPP
|
