← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ardour/vivid-proposed

« back to all changes in this revision

Viewing changes to libs/sigc++2/sigc++/adaptors/lambda/select.h

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler, Jaromír Mikeš, Felipe Sateler
  • Date: 2014-05-22 14:39:25 UTC
  • mfrom: (29 sid)
  • mto: This revision was merged to the branch mainline in revision 30.
  • Revision ID: package-import@ubuntu.com-20140522143925-vwqfo9287pmkrroe
Tags: 1:2.8.16+git20131003-3
* Team upload

[ Jaromír Mikeš ]
* Add -dbg package

[ Felipe Sateler ]
* Upload to experimental

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/sigc++2/sigc++/adaptors/lambda/select.h
 
1
// -*- c++ -*-
 
2
/* Do not edit! -- generated file */
 
3
#ifndef _SIGC_LAMBDA_SELECT_HPP_
 
4
#define _SIGC_LAMBDA_SELECT_HPP_
 
5
#include <sigc++/adaptors/lambda/base.h>
 
6
 
 
7
namespace sigc {
 
8
 
 
9
namespace internal {
 
10
struct lambda_select1 : public lambda_base
 
11
{
 
12
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
13
  struct deduce_result_type
 
14
    { typedef T_arg1 type; };
 
15
  typedef void result_type; // no operator ()() overload
 
16
 
 
17
  void operator ()() const; // not implemented
 
18
  template <class T_arg1>
 
19
  T_arg1 operator ()(T_arg1 _A_1) const { return _A_1; }
 
20
 
 
21
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
22
  template <class T_arg1>
 
23
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return operator()( _A_1 ); }
 
24
  T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return _A_1; }
 
25
  #endif
 
26
  
 
27
  template <class T_arg1,class T_arg2>
 
28
  T_arg1 operator ()(T_arg1 _A_1, T_arg2) const { return _A_1; }
 
29
 
 
30
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
31
  template <class T_arg1,class T_arg2>
 
32
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
 
33
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2) const { return _A_1; }
 
34
  #endif
 
35
  
 
36
  template <class T_arg1,class T_arg2,class T_arg3>
 
37
  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
 
38
 
 
39
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
40
  template <class T_arg1,class T_arg2,class T_arg3>
 
41
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
 
42
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
 
43
  #endif
 
44
  
 
45
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
46
  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
 
47
 
 
48
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
49
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
50
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
 
51
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
 
52
  #endif
 
53
  
 
54
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
55
  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
 
56
 
 
57
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
58
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
59
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
 
60
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
 
61
  #endif
 
62
  
 
63
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
64
  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
 
65
 
 
66
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
67
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
68
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
69
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
 
70
  #endif
 
71
  
 
72
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
73
  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
 
74
 
 
75
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
76
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
77
  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
78
  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
 
79
  #endif
 
80
  
 
81
};
 
82
 
 
83
struct lambda_select2 : public lambda_base
 
84
{
 
85
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
86
  struct deduce_result_type
 
87
    { typedef T_arg2 type; };
 
88
  typedef void result_type; // no operator ()() overload
 
89
 
 
90
  void operator ()() const; // not implemented
 
91
  template <class T_arg1,class T_arg2>
 
92
  T_arg2 operator ()(T_arg1, T_arg2 _A_2) const { return _A_2; }
 
93
 
 
94
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
95
  template <class T_arg1,class T_arg2>
 
96
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
 
97
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2) const { return _A_2; }
 
98
  #endif
 
99
  
 
100
  template <class T_arg1,class T_arg2,class T_arg3>
 
101
  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
 
102
 
 
103
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
104
  template <class T_arg1,class T_arg2,class T_arg3>
 
105
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
 
106
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
 
107
  #endif
 
108
  
 
109
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
110
  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
 
111
 
 
112
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
113
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
114
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
 
115
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
 
116
  #endif
 
117
  
 
118
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
119
  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
 
120
 
 
121
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
122
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
123
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
 
124
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
 
125
  #endif
 
126
  
 
127
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
128
  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
 
129
 
 
130
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
131
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
132
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
133
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
 
134
  #endif
 
135
  
 
136
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
137
  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
 
138
 
 
139
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
140
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
141
  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
142
  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
 
143
  #endif
 
144
  
 
145
};
 
146
 
 
147
struct lambda_select3 : public lambda_base
 
148
{
 
149
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
150
  struct deduce_result_type
 
151
    { typedef T_arg3 type; };
 
152
  typedef void result_type; // no operator ()() overload
 
153
 
 
154
  void operator ()() const; // not implemented
 
155
  template <class T_arg1,class T_arg2,class T_arg3>
 
156
  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
 
157
 
 
158
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
159
  template <class T_arg1,class T_arg2,class T_arg3>
 
160
  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
 
161
  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
 
162
  #endif
 
163
  
 
164
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
165
  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
 
166
 
 
167
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
168
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
169
  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
 
170
  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
 
171
  #endif
 
172
  
 
173
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
174
  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
 
175
 
 
176
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
177
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
178
  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
 
179
  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
 
180
  #endif
 
181
  
 
182
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
183
  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
 
184
 
 
185
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
186
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
187
  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
188
  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
 
189
  #endif
 
190
  
 
191
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
192
  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
 
193
 
 
194
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
195
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
196
  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
197
  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
 
198
  #endif
 
199
  
 
200
};
 
201
 
 
202
struct lambda_select4 : public lambda_base
 
203
{
 
204
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
205
  struct deduce_result_type
 
206
    { typedef T_arg4 type; };
 
207
  typedef void result_type; // no operator ()() overload
 
208
 
 
209
  void operator ()() const; // not implemented
 
210
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
211
  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
 
212
 
 
213
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
214
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 
215
  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
 
216
  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
 
217
  #endif
 
218
  
 
219
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
220
  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
 
221
 
 
222
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
223
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
224
  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
 
225
  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
 
226
  #endif
 
227
  
 
228
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
229
  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
 
230
 
 
231
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
232
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
233
  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
234
  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
 
235
  #endif
 
236
  
 
237
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
238
  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
 
239
 
 
240
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
241
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
242
  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
243
  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
 
244
  #endif
 
245
  
 
246
};
 
247
 
 
248
struct lambda_select5 : public lambda_base
 
249
{
 
250
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
251
  struct deduce_result_type
 
252
    { typedef T_arg5 type; };
 
253
  typedef void result_type; // no operator ()() overload
 
254
 
 
255
  void operator ()() const; // not implemented
 
256
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
257
  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
 
258
 
 
259
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
260
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 
261
  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
 
262
  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
 
263
  #endif
 
264
  
 
265
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
266
  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
 
267
 
 
268
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
269
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
270
  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
271
  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
 
272
  #endif
 
273
  
 
274
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
275
  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
 
276
 
 
277
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
278
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
279
  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
280
  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
 
281
  #endif
 
282
  
 
283
};
 
284
 
 
285
struct lambda_select6 : public lambda_base
 
286
{
 
287
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
288
  struct deduce_result_type
 
289
    { typedef T_arg6 type; };
 
290
  typedef void result_type; // no operator ()() overload
 
291
 
 
292
  void operator ()() const; // not implemented
 
293
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
294
  T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
 
295
 
 
296
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
297
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 
298
  //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
 
299
  T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
 
300
  #endif
 
301
  
 
302
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
303
  T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
 
304
 
 
305
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
306
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
307
  //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
308
  T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
 
309
  #endif
 
310
  
 
311
};
 
312
 
 
313
struct lambda_select7 : public lambda_base
 
314
{
 
315
  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
 
316
  struct deduce_result_type
 
317
    { typedef T_arg7 type; };
 
318
  typedef void result_type; // no operator ()() overload
 
319
 
 
320
  void operator ()() const; // not implemented
 
321
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
322
  T_arg7 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
 
323
 
 
324
  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
325
  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 
326
  //Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
 
327
  T_arg7 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
 
328
  #endif
 
329
  
 
330
};
 
331
 
 
332
 
 
333
} /* namespace internal */
 
334
 
 
335
extern SIGC_API const lambda<internal::lambda_select1> _1;
 
336
extern SIGC_API const lambda<internal::lambda_select2> _2;
 
337
extern SIGC_API const lambda<internal::lambda_select3> _3;
 
338
extern SIGC_API const lambda<internal::lambda_select4> _4;
 
339
extern SIGC_API const lambda<internal::lambda_select5> _5;
 
340
extern SIGC_API const lambda<internal::lambda_select6> _6;
 
341
extern SIGC_API const lambda<internal::lambda_select7> _7;
 
342
 
 
343
 
 
344
} /* namespace sigc */
 
345
 
 
346
#endif /* _SIGC_LAMBDA_SELECT_HPP_ */