← Back to branch summary

~ubuntu-branches/ubuntu/wily/ruby-passenger/wily-proposed

« back to all changes in this revision

Viewing changes to ext/boost/lambda/detail/operator_lambda_func_base.hpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-11-23 23:50:02 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20131123235002-8fdhsq7afj15o2z2
Tags: 4.0.25-1
http://bugs.debian.org/725591
* New upstream release.
* Refresh fix_install_path.patch.
* Build for Ruby 2.0 instead of 1.8. (Closes: #725591)
* Add fix_ftbfs_fortify_source.patch.
* Install passenger template files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/boost/lambda/detail/operator_lambda_func_base.hpp
1
 
// Boost Lambda Library  - operator_lambda_func_base.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_OPERATOR_LAMBDA_FUNC_BASE_HPP
14
 
#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
15
 
 
16
 
namespace boost { 
17
 
namespace lambda {
18
 
 
19
 
 
20
 
// These operators cannot be implemented as apply functions of action 
21
 
// templates
22
 
 
23
 
 
24
 
// Specialization for comma.
25
 
template<class Args>
26
 
class lambda_functor_base<other_action<comma_action>, Args> {
27
 
public:
28
 
  Args args;
29
 
public:
30
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
31
 
 
32
 
  template<class RET, CALL_TEMPLATE_ARGS>
33
 
  RET call(CALL_FORMAL_ARGS) const {
34
 
    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS), 
35
 
           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
36
 
  }
37
 
 
38
 
 
39
 
  template<class SigArgs> struct sig { 
40
 
  private:
41
 
    typedef typename
42
 
      detail::deduce_argument_types<Args, SigArgs>::type rets_t;      
43
 
  public:
44
 
    typedef typename return_type_2_comma< // comma needs special handling
45
 
      typename detail::element_or_null<0, rets_t>::type,
46
 
      typename detail::element_or_null<1, rets_t>::type
47
 
    >::type type;
48
 
  };
49
 
 
50
 
};  
51
 
 
52
 
namespace detail {
53
 
 
54
 
// helper traits to make the expression shorter, takes binary action
55
 
// bound argument tuple, open argument tuple and gives the return type
56
 
 
57
 
template<class Action, class Bound, class Open> class binary_rt {
58
 
  private:
59
 
    typedef typename
60
 
      detail::deduce_argument_types<Bound, Open>::type rets_t;      
61
 
  public:
62
 
    typedef typename return_type_2_prot<
63
 
      Action,  
64
 
      typename detail::element_or_null<0, rets_t>::type,
65
 
      typename detail::element_or_null<1, rets_t>::type
66
 
    >::type type;
67
 
};
68
 
 
69
 
 
70
 
  // same for unary actions
71
 
template<class Action, class Bound, class Open> class unary_rt {
72
 
  private:
73
 
    typedef typename
74
 
      detail::deduce_argument_types<Bound, Open>::type rets_t;      
75
 
  public:
76
 
    typedef typename return_type_1_prot<
77
 
      Action,  
78
 
      typename detail::element_or_null<0, rets_t>::type
79
 
    >::type type;
80
 
};
81
 
 
82
 
 
83
 
} // end detail
84
 
 
85
 
// Specialization for logical and (to preserve shortcircuiting)
86
 
// this could be done with a macro as the others, code used to be different
87
 
template<class Args>
88
 
class lambda_functor_base<logical_action<and_action>, Args> {
89
 
public:
90
 
  Args args;
91
 
public:
92
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
93
 
 
94
 
  template<class RET, CALL_TEMPLATE_ARGS>
95
 
  RET call(CALL_FORMAL_ARGS) const {
96
 
    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) && 
97
 
           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
98
 
  }
99
 
  template<class SigArgs> struct sig { 
100
 
    typedef typename
101
 
      detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type;
102
 
  };      
103
 
};  
104
 
 
105
 
// Specialization for logical or (to preserve shortcircuiting)
106
 
// this could be done with a macro as the others, code used to be different
107
 
template<class Args>
108
 
class lambda_functor_base<logical_action< or_action>, Args> {
109
 
public:
110
 
  Args args;
111
 
public:
112
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
113
 
 
114
 
  template<class RET, CALL_TEMPLATE_ARGS>
115
 
  RET call(CALL_FORMAL_ARGS) const {
116
 
    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) || 
117
 
           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
118
 
  }
119
 
 
120
 
  template<class SigArgs> struct sig { 
121
 
    typedef typename
122
 
      detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type;
123
 
  };      
124
 
};  
125
 
 
126
 
// Specialization for subscript
127
 
template<class Args>
128
 
class lambda_functor_base<other_action<subscript_action>, Args> {
129
 
public:
130
 
  Args args;
131
 
public:
132
 
  explicit lambda_functor_base(const Args& a) : args(a) {}
133
 
 
134
 
  template<class RET, CALL_TEMPLATE_ARGS>
135
 
  RET call(CALL_FORMAL_ARGS) const {
136
 
    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) 
137
 
           [detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)]; 
138
 
  }
139
 
 
140
 
  template<class SigArgs> struct sig { 
141
 
    typedef typename
142
 
      detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type 
143
 
        type;
144
 
  };      
145
 
};  
146
 
 
147
 
 
148
 
#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  \
149
 
template<class Args>                                                      \
150
 
class lambda_functor_base<ACTION_CLASS, Args> {                           \
151
 
public:                                                                   \
152
 
  Args args;                                                              \
153
 
public:                                                                   \
154
 
  explicit lambda_functor_base(const Args& a) : args(a) {}                \
155
 
                                                                          \
156
 
  template<class RET, CALL_TEMPLATE_ARGS>                                 \
157
 
  RET call(CALL_FORMAL_ARGS) const {                                      \
158
 
    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)  \
159
 
           SYMBOL                                                         \
160
 
           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
161
 
  }                                                                       \
162
 
  template<class SigArgs> struct sig {                                    \
163
 
    typedef typename                                                      \
164
 
      detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type;          \
165
 
  };                                                                      \
166
 
};  
167
 
 
168
 
#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)            \
169
 
template<class Args>                                                      \
170
 
class lambda_functor_base<ACTION_CLASS, Args> {                           \
171
 
public:                                                                   \
172
 
  Args args;                                                              \
173
 
public:                                                                   \
174
 
  explicit lambda_functor_base(const Args& a) : args(a) {}                \
175
 
                                                                          \
176
 
  template<class RET, CALL_TEMPLATE_ARGS>                                 \
177
 
  RET call(CALL_FORMAL_ARGS) const {                                      \
178
 
    return SYMBOL                                                         \
179
 
           detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \
180
 
  }                                                                       \
181
 
  template<class SigArgs> struct sig {                                    \
182
 
    typedef typename                                                      \
183
 
      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
184
 
  };                                                                      \
185
 
};  
186
 
 
187
 
#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)           \
188
 
template<class Args>                                                      \
189
 
class lambda_functor_base<ACTION_CLASS, Args> {                           \
190
 
public:                                                                   \
191
 
  Args args;                                                              \
192
 
public:                                                                   \
193
 
  explicit lambda_functor_base(const Args& a) : args(a) {}                \
194
 
                                                                          \
195
 
  template<class RET, CALL_TEMPLATE_ARGS>                                 \
196
 
  RET call(CALL_FORMAL_ARGS) const {                                      \
197
 
    return                                                                \
198
 
    detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \
199
 
  }                                                                       \
200
 
  template<class SigArgs> struct sig {                                    \
201
 
    typedef typename                                                      \
202
 
      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
203
 
  };                                                                      \
204
 
};  
205
 
 
206
 
BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
207
 
BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
208
 
BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
209
 
BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
210
 
BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
211
 
 
212
 
BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
213
 
BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
214
 
BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
215
 
BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
216
 
BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
217
 
 
218
 
BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
219
 
BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
220
 
BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
221
 
BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
222
 
BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
223
 
BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
224
 
 
225
 
BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
226
 
BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
227
 
BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
228
 
BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
229
 
BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
230
 
 
231
 
BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
232
 
BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
233
 
BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
234
 
BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
235
 
BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
236
 
 
237
 
BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
238
 
 
239
 
 
240
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
241
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
242
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
243
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
244
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
245
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
246
 
 
247
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
248
 
BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
249
 
 
250
 
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
251
 
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
252
 
 
253
 
 
254
 
#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
255
 
#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
256
 
#undef BOOST_LAMBDA_BINARY_ACTION
257
 
 
258
 
} // namespace lambda
259
 
} // namespace boost
260
 
 
261
 
#endif
262
 
 
263
 
 
264
 
 
265
 
 
266
 
 
267
 
 
268
 
 
269
 
 
270
 
 
271