Gitiles
Code Review Sign In
gerrit.named-data.net / ndn-cxx / 9939dcdf81b2c83a69663bf1113bae1e72610b3c / . / include / ndnboost / lambda / detail / operators.hpp
blob: 7c3bc8b3592464eaa568696c24fe58800ea16edf [file] [log] [blame]
Jeff Thompsonef2d5a42013-08-22 19:09:24 -0700[diff] [blame]1// Boost Lambda Library - operators.hpp --------------------------------------
2
3// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
4//
5// Distributed under the Boost Software License, Version 1.0. (See
6// accompanying file LICENSE_1_0.txt or copy at
7// http://www.boost.org/LICENSE_1_0.txt)
8//
9// For more information, see www.boost.org
10
11// ---------------------------------------------------------------
12
13#ifndef BOOST_LAMBDA_OPERATORS_HPP
14#define BOOST_LAMBDA_OPERATORS_HPP
15
16#include "ndnboost/lambda/detail/is_instance_of.hpp"
17
18namespace ndnboost {
19namespace lambda {
20
21#if defined BOOST_LAMBDA_BE1
22#error "Multiple defines of BOOST_LAMBDA_BE1"
23#endif
24
25 // For all BOOSTA_LAMBDA_BE* macros:
26
27 // CONSTA must be either 'A' or 'const A'
28 // CONSTB must be either 'B' or 'const B'
29
30 // It is stupid to have the names A and B as macro arguments, but it avoids
31 // the need to pass in emtpy macro arguments, which gives warnings on some
32 // compilers
33
34#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
35template<class Arg, class B> \
36inline const \
37lambda_functor< \
38 lambda_functor_base< \
39 ACTION, \
40 tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type> \
41 > \
42> \
43OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) { \
44 return \
45 lambda_functor_base< \
46 ACTION, \
47 tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
48 > \
49 (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
50}
51
52
53#if defined BOOST_LAMBDA_BE2
54#error "Multiple defines of BOOST_LAMBDA_BE2"
55#endif
56
57#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
58template<class A, class Arg> \
59inline const \
60lambda_functor< \
61 lambda_functor_base< \
62 ACTION, \
63 tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
64 > \
65> \
66OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) { \
67 return \
68 lambda_functor_base< \
69 ACTION, \
70 tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
71 > \
72 (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
73}
74
75
76#if defined BOOST_LAMBDA_BE3
77#error "Multiple defines of BOOST_LAMBDA_BE3"
78#endif
79
80#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
81template<class ArgA, class ArgB> \
82inline const \
83lambda_functor< \
84 lambda_functor_base< \
85 ACTION, \
86 tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
87 > \
88> \
89OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
90 return \
91 lambda_functor_base< \
92 ACTION, \
93 tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
94 > \
95 (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b)); \
96}
97
98#if defined BOOST_LAMBDA_BE
99#error "Multiple defines of BOOST_LAMBDA_BE"
100#endif
101
102#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
103BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
104BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
105BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
106
107#define BOOST_LAMBDA_EMPTY()
108
109BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
110BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
111BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
112BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
113BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
114BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
115BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
116BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
117BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
118BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
119BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
120BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
121BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
122BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
123BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
124BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
125BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
126BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
127
128BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
129BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
130BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
131BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
132BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
133BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
134BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
135BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
136BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
137BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
138
139
140// A special trick for comma operator for correct preprocessing
141#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
142#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
143#endif
144
145#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
146
147BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
148BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
149BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
150
151
152
153namespace detail {
154
155// special cases for ostream& << Any and istream& >> Any ---------------
156// the actual stream classes may vary and thus a specialisation for,
157// say ostream& does not match (the general case above is chosen).
158// Therefore we specialise for non-const reference:
159// if the left argument is a stream, we store the stream as reference
160// if it is something else, we store a const plain by default
161
162// Note that the overloading is const vs. non-const first argument
163
164#ifdef BOOST_NO_TEMPLATED_STREAMS
165template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
166 typedef typename detail::IF<
167 ndnboost::is_convertible<T*, std::ostream*>::value,
168 T&,
169 typename const_copy_argument <T>::type
170 >::RET type;
171};
172
173template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
174 typedef typename detail::IF<
175 ndnboost::is_convertible<T*, std::istream*>::value,
176 T&,
177 typename const_copy_argument <T>::type
178 >::RET type;
179};
180#else
181
182template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
183 typedef typename detail::IF<
184 is_instance_of_2<
185 T, std::basic_ostream
186 >::value,
187 T&,
188 typename const_copy_argument <T>::type
189 >::RET type;
190};
191
192template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
193 typedef typename detail::IF<
194 is_instance_of_2<
195 T, std::basic_istream
196 >::value,
197 T&,
198 typename const_copy_argument <T>::type
199 >::RET type;
200};
201#endif
202
203} // detail
204
205BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
206BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)
207
208
209// special case for io_manipulators.
210// function references cannot be given as arguments to lambda operator
211// expressions in general. With << and >> the use of manipulators is
212// so common, that specializations are provided to make them work.
213
214template<class Arg, class Ret, class ManipArg>
215inline const
216lambda_functor<
217 lambda_functor_base<
218 bitwise_action<leftshift_action>,
219 tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
220 >
221>
222operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
223{
224 return
225 lambda_functor_base<
226 bitwise_action<leftshift_action>,
227 tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
228 >
229 ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
230}
231
232template<class Arg, class Ret, class ManipArg>
233inline const
234lambda_functor<
235 lambda_functor_base<
236 bitwise_action<rightshift_action>,
237 tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
238 >
239>
240operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
241{
242 return
243 lambda_functor_base<
244 bitwise_action<rightshift_action>,
245 tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
246 >
247 ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
248}
249
250
251// (+ and -) take their arguments as const references.
252// This has consquences with pointer artihmetic
253// E.g int a[]; ... *a = 1 works but not *(a+1) = 1.
254// the result of a+1 would be const
255// To make the latter work too,
256// non-const arrays are taken as non-const and stored as non-const as well.
257#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E1
258#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E1"
259#endif
260
261#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB) \
262template<class Arg, int N, class B> \
263inline const \
264lambda_functor< \
265 lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
266> \
267OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N]) \
268{ \
269 return \
270 lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
271 (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b)); \
272}
273
274
275#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E2
276#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E2"
277#endif
278
279#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA) \
280template<int N, class A, class Arg> \
281inline const \
282lambda_functor< \
283 lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
284> \
285OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b) \
286{ \
287 return \
288 lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
289 (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b)); \
290}
291
292
293BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
294BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
295BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
296BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
297
298
299//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
300// This is not needed, since the result of ptr-ptr is an rvalue anyway
301
302BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
303BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
304
305
306#undef BOOST_LAMBDA_BE1
307#undef BOOST_LAMBDA_BE2
308#undef BOOST_LAMBDA_BE3
309#undef BOOST_LAMBDA_BE
310#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
311
312#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
313#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
314
315
316// ---------------------------------------------------------------------
317// unary operators -----------------------------------------------------
318// ---------------------------------------------------------------------
319
320#if defined BOOST_LAMBDA_UE
321#error "Multiple defines of BOOST_LAMBDA_UE"
322#endif
323
324#define BOOST_LAMBDA_UE(OPER_NAME, ACTION) \
325template<class Arg> \
326inline const \
327lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
328OPER_NAME (const lambda_functor<Arg>& a) \
329{ \
330 return \
331 lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
332 ( tuple<lambda_functor<Arg> >(a) ); \
333}
334
335
336BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
337BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
338BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
339BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
340BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
341BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
342BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
343BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
344
345#if defined BOOST_LAMBDA_POSTFIX_UE
346#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
347#endif
348
349#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION) \
350template<class Arg> \
351inline const \
352lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
353OPER_NAME (const lambda_functor<Arg>& a, int) \
354{ \
355 return \
356 lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
357 ( tuple<lambda_functor<Arg> >(a) ); \
358}
359
360
361BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
362BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
363
364#undef BOOST_LAMBDA_UE
365#undef BOOST_LAMBDA_POSTFIX_UE
366
367} // namespace lambda
368} // namespace ndnboost
369
370#endif