1#ifndef BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED
2#define BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED
3
4// Copyright 2020, 2021 Peter Dimov
5// Distributed under the Boost Software License, Version 1.0.
6// https://www.boost.org/LICENSE_1_0.txt
7
8#include <functional>
9#include <type_traits>
10#include <utility>
11#include <tuple>
12#include <cstddef>
13#include <iosfwd>
14
15// Same format as BOOST_VERSION:
16// major * 100000 + minor * 100 + patch
17#define BOOST_LAMBDA2_VERSION 108500
18
19namespace boost
20{
21namespace lambda2
22{
23
24namespace lambda2_detail
25{
26
27struct subscript
28{
29 template<class T1, class T2> decltype(auto) operator()(T1&& t1, T2&& t2) const
30 {
31 return std::forward<T1>(t1)[ std::forward<T2>(t2) ];
32 }
33};
34
35template<int I> struct get
36{
37 template<class T> decltype(auto) operator()( T&& t ) const
38 {
39 return std::get<I>( std::forward<T>(t) );
40 }
41};
42
43} // namespace lambda2_detail
44
45// placeholders
46
47template<int I> struct lambda2_arg
48{
49 template<class... A> decltype(auto) operator()( A&&... a ) const noexcept
50 {
51 return std::get<std::size_t{I-1}>( std::tuple<A&&...>( std::forward<A>(a)... ) );
52 }
53
54 template<class T> auto operator[]( T&& t ) const
55 {
56 return std::bind( lambda2_detail::subscript(), *this, std::forward<T>( t ) );
57 }
58};
59
60#if defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L
61# define BOOST_LAMBDA2_INLINE_VAR inline
62#else
63# define BOOST_LAMBDA2_INLINE_VAR
64#endif
65
66BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<1> _1{};
67BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<2> _2{};
68BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<3> _3{};
69BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<4> _4{};
70BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<5> _5{};
71BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<6> _6{};
72BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<7> _7{};
73BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<8> _8{};
74BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_arg<9> _9{};
75
76// first, second
77
78BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_detail::get<0> first{};
79BOOST_LAMBDA2_INLINE_VAR constexpr lambda2_detail::get<1> second{};
80
81#undef BOOST_LAMBDA2_INLINE_VAR
82
83} // namespace lambda2
84} // namespace boost
85
86namespace std
87{
88
89template<int I> struct is_placeholder< boost::lambda2::lambda2_arg<I> >: integral_constant<int, I>
90{
91};
92
93} // namespace std
94
95namespace boost
96{
97namespace lambda2
98{
99
100namespace lambda2_detail
101{
102
103// additional function objects
104
105#define BOOST_LAMBDA2_UNARY_FN(op, fn) \
106 struct fn \
107 { \
108 template<class T> decltype(auto) operator()(T&& t) const \
109 { \
110 return op std::forward<T>(t); \
111 } \
112 };
113
114#define BOOST_LAMBDA2_POSTFIX_FN(op, fn) \
115 struct fn \
116 { \
117 template<class T> decltype(auto) operator()(T&& t) const \
118 { \
119 return std::forward<T>(t) op; \
120 } \
121 };
122
123#define BOOST_LAMBDA2_BINARY_FN(op, fn) \
124 struct fn \
125 { \
126 template<class T1, class T2> decltype(auto) operator()(T1&& t1, T2&& t2) const \
127 { \
128 return std::forward<T1>(t1) op std::forward<T2>(t2); \
129 } \
130 };
131
132BOOST_LAMBDA2_BINARY_FN(<<, left_shift)
133BOOST_LAMBDA2_BINARY_FN(>>, right_shift)
134
135BOOST_LAMBDA2_UNARY_FN(+, unary_plus)
136BOOST_LAMBDA2_UNARY_FN(*, dereference)
137
138BOOST_LAMBDA2_UNARY_FN(++, increment)
139BOOST_LAMBDA2_UNARY_FN(--, decrement)
140
141BOOST_LAMBDA2_POSTFIX_FN(++, postfix_increment)
142BOOST_LAMBDA2_POSTFIX_FN(--, postfix_decrement)
143
144BOOST_LAMBDA2_BINARY_FN(+=, plus_equal)
145BOOST_LAMBDA2_BINARY_FN(-=, minus_equal)
146BOOST_LAMBDA2_BINARY_FN(*=, multiplies_equal)
147BOOST_LAMBDA2_BINARY_FN(/=, divides_equal)
148BOOST_LAMBDA2_BINARY_FN(%=, modulus_equal)
149BOOST_LAMBDA2_BINARY_FN(&=, bit_and_equal)
150BOOST_LAMBDA2_BINARY_FN(|=, bit_or_equal)
151BOOST_LAMBDA2_BINARY_FN(^=, bit_xor_equal)
152BOOST_LAMBDA2_BINARY_FN(<<=, left_shift_equal)
153BOOST_LAMBDA2_BINARY_FN(>>=, right_shift_equal)
154
155// operators
156
157template<class T> using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
158
159template<class T, class T2 = remove_cvref_t<T>> using is_lambda_expression =
160 std::integral_constant<bool, std::is_placeholder<T2>::value || std::is_bind_expression<T2>::value>;
161
162template<class A> using enable_unary_lambda =
163 std::enable_if_t<is_lambda_expression<A>::value>;
164
165template<class A, class B> using enable_binary_lambda =
166 std::enable_if_t<is_lambda_expression<A>::value || is_lambda_expression<B>::value>;
167
168template<class T> using is_stream = std::is_base_of<std::ios_base, remove_cvref_t<T>>;
169
170} // namespace lambda2_detail
171
172#define BOOST_LAMBDA2_UNARY_LAMBDA(op, fn) \
173 template<class A, class = lambda2_detail::enable_unary_lambda<A>> \
174 auto operator op( A&& a ) \
175 { \
176 return std::bind( fn(), std::forward<A>(a) ); \
177 }
178
179#define BOOST_LAMBDA2_POSTFIX_LAMBDA(op, fn) \
180 template<class A, class = lambda2_detail::enable_unary_lambda<A>> \
181 auto operator op( A&& a, int ) \
182 { \
183 return std::bind( fn(), std::forward<A>(a) ); \
184 }
185
186#define BOOST_LAMBDA2_BINARY_LAMBDA(op, fn) \
187 template<class A, class B, class = lambda2_detail::enable_binary_lambda<A, B>> \
188 auto operator op( A&& a, B&& b ) \
189 { \
190 return std::bind( fn(), std::forward<A>(a), std::forward<B>(b) ); \
191 }
192
193// standard
194
195BOOST_LAMBDA2_BINARY_LAMBDA(+, std::plus<>)
196BOOST_LAMBDA2_BINARY_LAMBDA(-, std::minus<>)
197BOOST_LAMBDA2_BINARY_LAMBDA(*, std::multiplies<>)
198BOOST_LAMBDA2_BINARY_LAMBDA(/, std::divides<>)
199BOOST_LAMBDA2_BINARY_LAMBDA(%, std::modulus<>)
200BOOST_LAMBDA2_UNARY_LAMBDA(-, std::negate<>)
201
202BOOST_LAMBDA2_BINARY_LAMBDA(==, std::equal_to<>)
203BOOST_LAMBDA2_BINARY_LAMBDA(!=, std::not_equal_to<>)
204BOOST_LAMBDA2_BINARY_LAMBDA(>, std::greater<>)
205BOOST_LAMBDA2_BINARY_LAMBDA(<, std::less<>)
206BOOST_LAMBDA2_BINARY_LAMBDA(>=, std::greater_equal<>)
207BOOST_LAMBDA2_BINARY_LAMBDA(<=, std::less_equal<>)
208
209BOOST_LAMBDA2_BINARY_LAMBDA(&&, std::logical_and<>)
210BOOST_LAMBDA2_BINARY_LAMBDA(||, std::logical_or<>)
211BOOST_LAMBDA2_UNARY_LAMBDA(!, std::logical_not<>)
212
213BOOST_LAMBDA2_BINARY_LAMBDA(&, std::bit_and<>)
214BOOST_LAMBDA2_BINARY_LAMBDA(|, std::bit_or<>)
215BOOST_LAMBDA2_BINARY_LAMBDA(^, std::bit_xor<>)
216BOOST_LAMBDA2_UNARY_LAMBDA(~, std::bit_not<>)
217
218// additional
219
220BOOST_LAMBDA2_UNARY_LAMBDA(+, lambda2_detail::unary_plus)
221BOOST_LAMBDA2_UNARY_LAMBDA(*, lambda2_detail::dereference)
222
223BOOST_LAMBDA2_UNARY_LAMBDA(++, lambda2_detail::increment)
224BOOST_LAMBDA2_UNARY_LAMBDA(--, lambda2_detail::decrement)
225
226BOOST_LAMBDA2_POSTFIX_LAMBDA(++, lambda2_detail::postfix_increment)
227BOOST_LAMBDA2_POSTFIX_LAMBDA(--, lambda2_detail::postfix_decrement)
228
229// compound assignment
230
231BOOST_LAMBDA2_BINARY_LAMBDA(+=, lambda2_detail::plus_equal)
232BOOST_LAMBDA2_BINARY_LAMBDA(-=, lambda2_detail::minus_equal)
233BOOST_LAMBDA2_BINARY_LAMBDA(*=, lambda2_detail::multiplies_equal)
234BOOST_LAMBDA2_BINARY_LAMBDA(/=, lambda2_detail::divides_equal)
235BOOST_LAMBDA2_BINARY_LAMBDA(%=, lambda2_detail::modulus_equal)
236BOOST_LAMBDA2_BINARY_LAMBDA(&=, lambda2_detail::bit_and_equal)
237BOOST_LAMBDA2_BINARY_LAMBDA(|=, lambda2_detail::bit_or_equal)
238BOOST_LAMBDA2_BINARY_LAMBDA(^=, lambda2_detail::bit_xor_equal)
239BOOST_LAMBDA2_BINARY_LAMBDA(<<=, lambda2_detail::left_shift_equal)
240BOOST_LAMBDA2_BINARY_LAMBDA(>>=, lambda2_detail::right_shift_equal)
241
242// operator<<
243
244template<class A, class = std::enable_if_t<!lambda2_detail::is_stream<A>::value>,
245 class B, class = lambda2_detail::enable_binary_lambda<A, B>>
246auto operator<<( A&& a, B&& b )
247{
248 return std::bind( lambda2_detail::left_shift(), std::forward<A>(a), std::forward<B>(b) );
249}
250
251template<class A, class = std::enable_if_t<lambda2_detail::is_stream<A>::value>,
252 class B, class = lambda2_detail::enable_unary_lambda<B>>
253auto operator<<( A& a, B&& b )
254{
255 return std::bind( lambda2_detail::left_shift(), std::ref(a), std::forward<B>(b) );
256}
257
258// operator>>
259
260template<class A, class = std::enable_if_t<!lambda2_detail::is_stream<A>::value>,
261 class B, class = lambda2_detail::enable_binary_lambda<A, B>>
262auto operator>>( A&& a, B&& b )
263{
264 return std::bind( lambda2_detail::right_shift(), std::forward<A>(a), std::forward<B>(b) );
265}
266
267template<class A, class = std::enable_if_t<lambda2_detail::is_stream<A>::value>,
268 class B, class = lambda2_detail::enable_unary_lambda<B>>
269auto operator>>( A& a, B&& b )
270{
271 return std::bind( lambda2_detail::right_shift(), std::ref(a), std::forward<B>(b) );
272}
273
274// operator->*
275
276template<class A, class B, class = lambda2_detail::enable_unary_lambda<A>>
277auto operator->*( A&& a, B&& b )
278{
279 return std::bind( std::forward<B>(b), std::forward<A>(a) );
280}
281
282} // namespace lambda2
283} // namespace boost
284
285#endif // #ifndef BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED
286

source code of boost/libs/lambda2/include/boost/lambda2/lambda2.hpp