1 // -*- c++ -*- 2 /* Do not edit! -- generated file */ 3 #ifndef _SIGC_ADAPTORS_HIDE_H_ 4 #define _SIGC_ADAPTORS_HIDE_H_ 5 #include <sigc++/adaptors/adaptor_trait.h> 6 7 namespace sigc { 8 9 /** @defgroup hide hide(), hide_return() 10 * sigc::hide() alters an arbitrary functor in that it adds a parameter 11 * whose value is ignored on invocation of the returned functor. 12 * Thus you can discard one argument of a signal. 13 * 14 * You may optionally specify the zero-based position of the parameter 15 * to ignore as a template argument. The default is to ignore the last 16 * parameter. 17 * (A value of @p -1 adds a parameter at the end so sigc::hide<-1>() gives the same result as sigc::hide().) 18 * 19 * The type of the parameter can optionally be specified if not deduced. 20 * 21 * @par Examples: 22 * @code 23 * void foo(int, int); 24 * // single argument hiding ... 25 * sigc::hide(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) 26 * sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2)) 27 * sigc::hide<0>(&foo)(1,2,3); // adds a dummy parameter at the beginning and calls foo(2,3) 28 * sigc::hide<1>(&foo)(1,2,3); // adds a dummy parameter in the middle and calls foo(1,3) 29 * sigc::hide<2>(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) 30 * @endcode 31 * 32 * The functor sigc::hide() returns can be directly passed into 33 * sigc::signal::connect(). 34 * 35 * @par Example: 36 * @code 37 * sigc::signal<void,int> some_signal; 38 * void foo(); 39 * some_signal.connect(sigc::hide(&foo)); 40 * @endcode 41 * 42 * sigc::hide() can be nested in order to discard multiple arguments. 43 * @par Example: 44 * @code 45 * // multiple argument hiding ... 46 * sigc::hide(sigc::hide(&foo))(1,2,3,4); // adds two dummy parameters at the back and calls foo(1,2) 47 * @endcode 48 49 * sigc::hide_return() alters an arbitrary functor by 50 * dropping its return value, thus converting it to a void functor. 51 * 52 * @ingroup adaptors 53 */ 54 55 /** Adaptor that adds a dummy parameter to the wrapped functor. 56 * Use the convenience function sigc::hide() to create an instance of sigc::hide_functor. 57 * 58 * The following template arguments are used: 59 * - @e I_location Zero-based position of the dummy parameter (@p -1 for the last parameter). 60 * - @e T_type Type of the dummy parameter. 61 * - @e T_functor Type of the functor to wrap. 62 * 63 * @ingroup hide 64 */ 65 template <int I_location, class T_functor> 66 #ifndef DOXYGEN_SHOULD_SKIP_THIS 67 struct hide_functor; 68 #else 69 struct hide_functor {}; 70 #endif 71 72 /** Adaptor that adds a dummy parameter to the wrapped functor. 73 * This template specialization ignores the value of the last parameter in operator()(). 74 * 75 * @ingroup hide 76 */ 77 template <class T_functor> 78 struct hide_functor <-1, T_functor> : public adapts<T_functor> 79 { 80 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 81 82 #ifndef DOXYGEN_SHOULD_SKIP_THIS 83 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> 84 struct deduce_result_type 85 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; }; 86 #endif // DOXYGEN_SHOULD_SKIP_THIS 87 typedef typename adaptor_type::result_type result_type; 88 89 /** Invokes the wrapped functor ignoring the only argument. 90 * @param _A_a1 Argument to be ignored. 91 * @return The return value of the functor invocation. 92 */ 93 template <class T_arg1> 94 typename deduce_result_type<T_arg1>::type 95 operator()(T_arg1) 96 { return this->functor_(); } 97 98 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 99 template <class T_arg1> 100 typename deduce_result_type<T_arg1>::type 101 sun_forte_workaround(T_arg1 _A_a1) 102 { return this->functor_(); } 103 #endif 104 105 /** Invokes the wrapped functor, ignoring the last argument. 106 * @param _A_a1 Argument to be passed on to the functor. 107 * @param _A_a2 Argument to be ignored. 108 * @return The return value of the functor invocation. 109 */ 110 template <class T_arg1, class T_arg2> 111 typename deduce_result_type<T_arg1, T_arg2>::type 112 operator()(T_arg1 _A_a1, T_arg2) 113 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>> 114 (_A_a1); } 115 116 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 117 template <class T_arg1, class T_arg2> 118 typename deduce_result_type<T_arg1, T_arg2>::type 119 sun_forte_workaround(T_arg1 _A_a1, T_arg2) 120 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>> 121 (_A_a1); } 122 #endif 123 124 /** Invokes the wrapped functor, ignoring the last argument. 125 * @param _A_a1 Argument to be passed on to the functor. 126 * @param _A_a2 Argument to be passed on to the functor. 127 * @param _A_a3 Argument to be ignored. 128 * @return The return value of the functor invocation. 129 */ 130 template <class T_arg1, class T_arg2, class T_arg3> 131 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 132 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3) 133 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>> 134 (_A_a1, _A_a2); } 135 136 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 137 template <class T_arg1, class T_arg2, class T_arg3> 138 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 139 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3) 140 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>> 141 (_A_a1, _A_a2); } 142 #endif 143 144 /** Invokes the wrapped functor, ignoring the last argument. 145 * @param _A_a1 Argument to be passed on to the functor. 146 * @param _A_a2 Argument to be passed on to the functor. 147 * @param _A_a3 Argument to be passed on to the functor. 148 * @param _A_a4 Argument to be ignored. 149 * @return The return value of the functor invocation. 150 */ 151 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 152 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 153 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4) 154 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 155 (_A_a1, _A_a2, _A_a3); } 156 157 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 158 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 159 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 160 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4) 161 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 162 (_A_a1, _A_a2, _A_a3); } 163 #endif 164 165 /** Invokes the wrapped functor, ignoring the last argument. 166 * @param _A_a1 Argument to be passed on to the functor. 167 * @param _A_a2 Argument to be passed on to the functor. 168 * @param _A_a3 Argument to be passed on to the functor. 169 * @param _A_a4 Argument to be passed on to the functor. 170 * @param _A_a5 Argument to be ignored. 171 * @return The return value of the functor invocation. 172 */ 173 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 174 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 175 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5) 176 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 177 (_A_a1, _A_a2, _A_a3, _A_a4); } 178 179 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 180 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 181 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 182 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5) 183 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 184 (_A_a1, _A_a2, _A_a3, _A_a4); } 185 #endif 186 187 /** Invokes the wrapped functor, ignoring the last argument. 188 * @param _A_a1 Argument to be passed on to the functor. 189 * @param _A_a2 Argument to be passed on to the functor. 190 * @param _A_a3 Argument to be passed on to the functor. 191 * @param _A_a4 Argument to be passed on to the functor. 192 * @param _A_a5 Argument to be passed on to the functor. 193 * @param _A_a6 Argument to be ignored. 194 * @return The return value of the functor invocation. 195 */ 196 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 197 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 198 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6) 199 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 200 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); } 201 202 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 203 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 204 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 205 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6) 206 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 207 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); } 208 #endif 209 210 /** Invokes the wrapped functor, ignoring the last argument. 211 * @param _A_a1 Argument to be passed on to the functor. 212 * @param _A_a2 Argument to be passed on to the functor. 213 * @param _A_a3 Argument to be passed on to the functor. 214 * @param _A_a4 Argument to be passed on to the functor. 215 * @param _A_a5 Argument to be passed on to the functor. 216 * @param _A_a6 Argument to be passed on to the functor. 217 * @param _A_a7 Argument to be ignored. 218 * @return The return value of the functor invocation. 219 */ 220 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 221 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 222 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7) 223 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 224 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 225 226 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 227 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 228 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 229 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7) 230 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 231 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 232 #endif 233 234 235 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 236 * @param _A_func Functor to invoke from operator()(). 237 */ 238 explicit hide_functor(const T_functor& _A_func) 239 : adapts<T_functor>(_A_func) 240 {} 241 }; 242 243 /** Adaptor that adds a dummy parameter to the wrapped functor. 244 * This template specialization ignores the value of the 1st parameter in operator()(). 245 * 246 * @ingroup hide 247 */ 248 template <class T_functor> 249 struct hide_functor <0, T_functor> : public adapts<T_functor> 250 { 251 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 252 253 #ifndef DOXYGEN_SHOULD_SKIP_THIS 254 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> 255 struct deduce_result_type 256 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; }; 257 #endif // DOXYGEN_SHOULD_SKIP_THIS 258 typedef typename adaptor_type::result_type result_type; 259 260 /** Invokes the wrapped functor ignoring the only argument. 261 * @param _A_a1 Argument to be ignored. 262 * @return The return value of the functor invocation. 263 */ 264 template <class T_arg1> 265 typename deduce_result_type<T_arg1>::type 266 operator()(T_arg1) 267 { return this->functor_(); } 268 269 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 270 template <class T_arg1> 271 typename deduce_result_type<T_arg1>::type 272 sun_forte_workaround(T_arg1 _A_a1) 273 { return this->functor_(); } 274 #endif 275 276 /** Invokes the wrapped functor, ignoring the 1st argument. 277 * @param _A_a1 Argument to be ignored. 278 * @param _A_a2 Argument to be passed on to the functor. 279 * @return The return value of the functor invocation. 280 */ 281 template <class T_arg1, class T_arg2> 282 typename deduce_result_type<T_arg1, T_arg2>::type 283 operator()(T_arg1, T_arg2 _A_a2) 284 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>> 285 (_A_a2); } 286 287 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 288 template <class T_arg1, class T_arg2> 289 typename deduce_result_type<T_arg1, T_arg2>::type 290 sun_forte_workaround(T_arg1, T_arg2 _A_a2) 291 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>> 292 (_A_a2); } 293 #endif 294 295 /** Invokes the wrapped functor, ignoring the 1st argument. 296 * @param _A_a1 Argument to be ignored. 297 * @param _A_a2 Argument to be passed on to the functor. 298 * @param _A_a3 Argument to be passed on to the functor. 299 * @return The return value of the functor invocation. 300 */ 301 template <class T_arg1, class T_arg2, class T_arg3> 302 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 303 operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3) 304 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 305 (_A_a2, _A_a3); } 306 307 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 308 template <class T_arg1, class T_arg2, class T_arg3> 309 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 310 sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3) 311 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 312 (_A_a2, _A_a3); } 313 #endif 314 315 /** Invokes the wrapped functor, ignoring the 1st argument. 316 * @param _A_a1 Argument to be ignored. 317 * @param _A_a2 Argument to be passed on to the functor. 318 * @param _A_a3 Argument to be passed on to the functor. 319 * @param _A_a4 Argument to be passed on to the functor. 320 * @return The return value of the functor invocation. 321 */ 322 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 323 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 324 operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4) 325 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 326 (_A_a2, _A_a3, _A_a4); } 327 328 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 329 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 330 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 331 sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4) 332 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 333 (_A_a2, _A_a3, _A_a4); } 334 #endif 335 336 /** Invokes the wrapped functor, ignoring the 1st argument. 337 * @param _A_a1 Argument to be ignored. 338 * @param _A_a2 Argument to be passed on to the functor. 339 * @param _A_a3 Argument to be passed on to the functor. 340 * @param _A_a4 Argument to be passed on to the functor. 341 * @param _A_a5 Argument to be passed on to the functor. 342 * @return The return value of the functor invocation. 343 */ 344 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 345 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 346 operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5) 347 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 348 (_A_a2, _A_a3, _A_a4, _A_a5); } 349 350 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 351 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 352 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 353 sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5) 354 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 355 (_A_a2, _A_a3, _A_a4, _A_a5); } 356 #endif 357 358 /** Invokes the wrapped functor, ignoring the 1st argument. 359 * @param _A_a1 Argument to be ignored. 360 * @param _A_a2 Argument to be passed on to the functor. 361 * @param _A_a3 Argument to be passed on to the functor. 362 * @param _A_a4 Argument to be passed on to the functor. 363 * @param _A_a5 Argument to be passed on to the functor. 364 * @param _A_a6 Argument to be passed on to the functor. 365 * @return The return value of the functor invocation. 366 */ 367 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 368 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 369 operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 370 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 371 (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 372 373 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 374 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 375 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 376 sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 377 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 378 (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 379 #endif 380 381 /** Invokes the wrapped functor, ignoring the 1st argument. 382 * @param _A_a1 Argument to be ignored. 383 * @param _A_a2 Argument to be passed on to the functor. 384 * @param _A_a3 Argument to be passed on to the functor. 385 * @param _A_a4 Argument to be passed on to the functor. 386 * @param _A_a5 Argument to be passed on to the functor. 387 * @param _A_a6 Argument to be passed on to the functor. 388 * @param _A_a7 Argument to be passed on to the functor. 389 * @return The return value of the functor invocation. 390 */ 391 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 392 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 393 operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 394 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 395 (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); } 396 397 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 398 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 399 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 400 sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 401 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 402 (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); } 403 #endif 404 405 406 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 407 * @param _A_func Functor to invoke from operator()(). 408 */ 409 explicit hide_functor(const T_functor& _A_func) 410 : adapts<T_functor>(_A_func) 411 {} 412 }; 413 414 #ifndef DOXYGEN_SHOULD_SKIP_THIS 415 /** Adaptor that adds a dummy parameter to the wrapped functor. 416 * This template specialization ignores the value of the 2nd parameter in operator()(). 417 * 418 * @ingroup hide 419 */ 420 template <class T_functor> 421 struct hide_functor <1, T_functor> : public adapts<T_functor> 422 { 423 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 424 425 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> 426 struct deduce_result_type 427 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; }; 428 typedef typename adaptor_type::result_type result_type; 429 430 /** Invokes the wrapped functor, ignoring the 2nd argument. 431 * @param _A_a1 Argument to be passed on to the functor. 432 * @param _A_a2 Argument to be ignored. 433 * @return The return value of the functor invocation. 434 */ 435 template <class T_arg1, class T_arg2> 436 typename deduce_result_type<T_arg1, T_arg2>::type 437 operator()(T_arg1 _A_a1, T_arg2) 438 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>> 439 (_A_a1); } 440 441 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 442 template <class T_arg1, class T_arg2> 443 typename deduce_result_type<T_arg1, T_arg2>::type 444 sun_forte_workaround(T_arg1 _A_a1, T_arg2) 445 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>> 446 (_A_a1); } 447 #endif 448 449 /** Invokes the wrapped functor, ignoring the 2nd argument. 450 * @param _A_a1 Argument to be passed on to the functor. 451 * @param _A_a2 Argument to be ignored. 452 * @param _A_a3 Argument to be passed on to the functor. 453 * @return The return value of the functor invocation. 454 */ 455 template <class T_arg1, class T_arg2, class T_arg3> 456 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 457 operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3) 458 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>> 459 (_A_a1, _A_a3); } 460 461 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 462 template <class T_arg1, class T_arg2, class T_arg3> 463 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 464 sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3) 465 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>> 466 (_A_a1, _A_a3); } 467 #endif 468 469 /** Invokes the wrapped functor, ignoring the 2nd argument. 470 * @param _A_a1 Argument to be passed on to the functor. 471 * @param _A_a2 Argument to be ignored. 472 * @param _A_a3 Argument to be passed on to the functor. 473 * @param _A_a4 Argument to be passed on to the functor. 474 * @return The return value of the functor invocation. 475 */ 476 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 477 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 478 operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4) 479 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 480 (_A_a1, _A_a3, _A_a4); } 481 482 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 483 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 484 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 485 sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4) 486 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 487 (_A_a1, _A_a3, _A_a4); } 488 #endif 489 490 /** Invokes the wrapped functor, ignoring the 2nd argument. 491 * @param _A_a1 Argument to be passed on to the functor. 492 * @param _A_a2 Argument to be ignored. 493 * @param _A_a3 Argument to be passed on to the functor. 494 * @param _A_a4 Argument to be passed on to the functor. 495 * @param _A_a5 Argument to be passed on to the functor. 496 * @return The return value of the functor invocation. 497 */ 498 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 499 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 500 operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5) 501 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 502 (_A_a1, _A_a3, _A_a4, _A_a5); } 503 504 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 505 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 506 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 507 sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5) 508 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 509 (_A_a1, _A_a3, _A_a4, _A_a5); } 510 #endif 511 512 /** Invokes the wrapped functor, ignoring the 2nd argument. 513 * @param _A_a1 Argument to be passed on to the functor. 514 * @param _A_a2 Argument to be ignored. 515 * @param _A_a3 Argument to be passed on to the functor. 516 * @param _A_a4 Argument to be passed on to the functor. 517 * @param _A_a5 Argument to be passed on to the functor. 518 * @param _A_a6 Argument to be passed on to the functor. 519 * @return The return value of the functor invocation. 520 */ 521 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 522 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 523 operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 524 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 525 (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); } 526 527 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 528 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 529 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 530 sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 531 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 532 (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); } 533 #endif 534 535 /** Invokes the wrapped functor, ignoring the 2nd argument. 536 * @param _A_a1 Argument to be passed on to the functor. 537 * @param _A_a2 Argument to be ignored. 538 * @param _A_a3 Argument to be passed on to the functor. 539 * @param _A_a4 Argument to be passed on to the functor. 540 * @param _A_a5 Argument to be passed on to the functor. 541 * @param _A_a6 Argument to be passed on to the functor. 542 * @param _A_a7 Argument to be passed on to the functor. 543 * @return The return value of the functor invocation. 544 */ 545 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 546 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 547 operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 548 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 549 (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); } 550 551 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 552 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 553 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 554 sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 555 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 556 (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); } 557 #endif 558 559 560 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 561 * @param _A_func Functor to invoke from operator()(). 562 */ 563 explicit hide_functor(const T_functor& _A_func) 564 : adapts<T_functor>(_A_func) 565 {} 566 }; 567 568 /** Adaptor that adds a dummy parameter to the wrapped functor. 569 * This template specialization ignores the value of the 3rd parameter in operator()(). 570 * 571 * @ingroup hide 572 */ 573 template <class T_functor> 574 struct hide_functor <2, T_functor> : public adapts<T_functor> 575 { 576 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 577 578 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> 579 struct deduce_result_type 580 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; }; 581 typedef typename adaptor_type::result_type result_type; 582 583 /** Invokes the wrapped functor, ignoring the 3rd argument. 584 * @param _A_a1 Argument to be passed on to the functor. 585 * @param _A_a2 Argument to be passed on to the functor. 586 * @param _A_a3 Argument to be ignored. 587 * @return The return value of the functor invocation. 588 */ 589 template <class T_arg1, class T_arg2, class T_arg3> 590 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 591 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3) 592 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>> 593 (_A_a1, _A_a2); } 594 595 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 596 template <class T_arg1, class T_arg2, class T_arg3> 597 typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type 598 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3) 599 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>> 600 (_A_a1, _A_a2); } 601 #endif 602 603 /** Invokes the wrapped functor, ignoring the 3rd argument. 604 * @param _A_a1 Argument to be passed on to the functor. 605 * @param _A_a2 Argument to be passed on to the functor. 606 * @param _A_a3 Argument to be ignored. 607 * @param _A_a4 Argument to be passed on to the functor. 608 * @return The return value of the functor invocation. 609 */ 610 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 611 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 612 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4) 613 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>> 614 (_A_a1, _A_a2, _A_a4); } 615 616 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 617 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 618 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 619 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4) 620 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>> 621 (_A_a1, _A_a2, _A_a4); } 622 #endif 623 624 /** Invokes the wrapped functor, ignoring the 3rd argument. 625 * @param _A_a1 Argument to be passed on to the functor. 626 * @param _A_a2 Argument to be passed on to the functor. 627 * @param _A_a3 Argument to be ignored. 628 * @param _A_a4 Argument to be passed on to the functor. 629 * @param _A_a5 Argument to be passed on to the functor. 630 * @return The return value of the functor invocation. 631 */ 632 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 633 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 634 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5) 635 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 636 (_A_a1, _A_a2, _A_a4, _A_a5); } 637 638 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 639 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 640 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 641 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5) 642 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 643 (_A_a1, _A_a2, _A_a4, _A_a5); } 644 #endif 645 646 /** Invokes the wrapped functor, ignoring the 3rd argument. 647 * @param _A_a1 Argument to be passed on to the functor. 648 * @param _A_a2 Argument to be passed on to the functor. 649 * @param _A_a3 Argument to be ignored. 650 * @param _A_a4 Argument to be passed on to the functor. 651 * @param _A_a5 Argument to be passed on to the functor. 652 * @param _A_a6 Argument to be passed on to the functor. 653 * @return The return value of the functor invocation. 654 */ 655 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 656 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 657 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 658 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 659 (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); } 660 661 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 662 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 663 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 664 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6) 665 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 666 (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); } 667 #endif 668 669 /** Invokes the wrapped functor, ignoring the 3rd argument. 670 * @param _A_a1 Argument to be passed on to the functor. 671 * @param _A_a2 Argument to be passed on to the functor. 672 * @param _A_a3 Argument to be ignored. 673 * @param _A_a4 Argument to be passed on to the functor. 674 * @param _A_a5 Argument to be passed on to the functor. 675 * @param _A_a6 Argument to be passed on to the functor. 676 * @param _A_a7 Argument to be passed on to the functor. 677 * @return The return value of the functor invocation. 678 */ 679 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 680 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 681 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 682 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 683 (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); } 684 685 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 686 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 687 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 688 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 689 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 690 (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); } 691 #endif 692 693 694 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 695 * @param _A_func Functor to invoke from operator()(). 696 */ 697 explicit hide_functor(const T_functor& _A_func) 698 : adapts<T_functor>(_A_func) 699 {} 700 }; 701 702 /** Adaptor that adds a dummy parameter to the wrapped functor. 703 * This template specialization ignores the value of the 4th parameter in operator()(). 704 * 705 * @ingroup hide 706 */ 707 template <class T_functor> 708 struct hide_functor <3, T_functor> : public adapts<T_functor> 709 { 710 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 711 712 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> 713 struct deduce_result_type 714 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; }; 715 typedef typename adaptor_type::result_type result_type; 716 717 /** Invokes the wrapped functor, ignoring the 4th argument. 718 * @param _A_a1 Argument to be passed on to the functor. 719 * @param _A_a2 Argument to be passed on to the functor. 720 * @param _A_a3 Argument to be passed on to the functor. 721 * @param _A_a4 Argument to be ignored. 722 * @return The return value of the functor invocation. 723 */ 724 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 725 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 726 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4) 727 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 728 (_A_a1, _A_a2, _A_a3); } 729 730 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 731 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4> 732 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type 733 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4) 734 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>> 735 (_A_a1, _A_a2, _A_a3); } 736 #endif 737 738 /** Invokes the wrapped functor, ignoring the 4th argument. 739 * @param _A_a1 Argument to be passed on to the functor. 740 * @param _A_a2 Argument to be passed on to the functor. 741 * @param _A_a3 Argument to be passed on to the functor. 742 * @param _A_a4 Argument to be ignored. 743 * @param _A_a5 Argument to be passed on to the functor. 744 * @return The return value of the functor invocation. 745 */ 746 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 747 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 748 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5) 749 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>> 750 (_A_a1, _A_a2, _A_a3, _A_a5); } 751 752 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 753 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 754 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 755 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5) 756 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>> 757 (_A_a1, _A_a2, _A_a3, _A_a5); } 758 #endif 759 760 /** Invokes the wrapped functor, ignoring the 4th argument. 761 * @param _A_a1 Argument to be passed on to the functor. 762 * @param _A_a2 Argument to be passed on to the functor. 763 * @param _A_a3 Argument to be passed on to the functor. 764 * @param _A_a4 Argument to be ignored. 765 * @param _A_a5 Argument to be passed on to the functor. 766 * @param _A_a6 Argument to be passed on to the functor. 767 * @return The return value of the functor invocation. 768 */ 769 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 770 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 771 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6) 772 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 773 (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); } 774 775 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 776 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 777 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 778 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6) 779 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 780 (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); } 781 #endif 782 783 /** Invokes the wrapped functor, ignoring the 4th argument. 784 * @param _A_a1 Argument to be passed on to the functor. 785 * @param _A_a2 Argument to be passed on to the functor. 786 * @param _A_a3 Argument to be passed on to the functor. 787 * @param _A_a4 Argument to be ignored. 788 * @param _A_a5 Argument to be passed on to the functor. 789 * @param _A_a6 Argument to be passed on to the functor. 790 * @param _A_a7 Argument to be passed on to the functor. 791 * @return The return value of the functor invocation. 792 */ 793 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 794 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 795 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 796 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 797 (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); } 798 799 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 800 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 801 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 802 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7) 803 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 804 (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); } 805 #endif 806 807 808 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 809 * @param _A_func Functor to invoke from operator()(). 810 */ 811 explicit hide_functor(const T_functor& _A_func) 812 : adapts<T_functor>(_A_func) 813 {} 814 }; 815 816 /** Adaptor that adds a dummy parameter to the wrapped functor. 817 * This template specialization ignores the value of the 5th parameter in operator()(). 818 * 819 * @ingroup hide 820 */ 821 template <class T_functor> 822 struct hide_functor <4, T_functor> : public adapts<T_functor> 823 { 824 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 825 826 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> 827 struct deduce_result_type 828 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; }; 829 typedef typename adaptor_type::result_type result_type; 830 831 /** Invokes the wrapped functor, ignoring the 5th argument. 832 * @param _A_a1 Argument to be passed on to the functor. 833 * @param _A_a2 Argument to be passed on to the functor. 834 * @param _A_a3 Argument to be passed on to the functor. 835 * @param _A_a4 Argument to be passed on to the functor. 836 * @param _A_a5 Argument to be ignored. 837 * @return The return value of the functor invocation. 838 */ 839 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 840 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 841 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5) 842 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 843 (_A_a1, _A_a2, _A_a3, _A_a4); } 844 845 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 846 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> 847 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type 848 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5) 849 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>> 850 (_A_a1, _A_a2, _A_a3, _A_a4); } 851 #endif 852 853 /** Invokes the wrapped functor, ignoring the 5th argument. 854 * @param _A_a1 Argument to be passed on to the functor. 855 * @param _A_a2 Argument to be passed on to the functor. 856 * @param _A_a3 Argument to be passed on to the functor. 857 * @param _A_a4 Argument to be passed on to the functor. 858 * @param _A_a5 Argument to be ignored. 859 * @param _A_a6 Argument to be passed on to the functor. 860 * @return The return value of the functor invocation. 861 */ 862 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 863 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 864 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6) 865 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>> 866 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); } 867 868 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 869 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 870 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 871 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6) 872 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>> 873 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); } 874 #endif 875 876 /** Invokes the wrapped functor, ignoring the 5th argument. 877 * @param _A_a1 Argument to be passed on to the functor. 878 * @param _A_a2 Argument to be passed on to the functor. 879 * @param _A_a3 Argument to be passed on to the functor. 880 * @param _A_a4 Argument to be passed on to the functor. 881 * @param _A_a5 Argument to be ignored. 882 * @param _A_a6 Argument to be passed on to the functor. 883 * @param _A_a7 Argument to be passed on to the functor. 884 * @return The return value of the functor invocation. 885 */ 886 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 887 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 888 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7) 889 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 890 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); } 891 892 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 893 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 894 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 895 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7) 896 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>> 897 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); } 898 #endif 899 900 901 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 902 * @param _A_func Functor to invoke from operator()(). 903 */ 904 explicit hide_functor(const T_functor& _A_func) 905 : adapts<T_functor>(_A_func) 906 {} 907 }; 908 909 /** Adaptor that adds a dummy parameter to the wrapped functor. 910 * This template specialization ignores the value of the 6th parameter in operator()(). 911 * 912 * @ingroup hide 913 */ 914 template <class T_functor> 915 struct hide_functor <5, T_functor> : public adapts<T_functor> 916 { 917 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 918 919 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> 920 struct deduce_result_type 921 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>>::type type; }; 922 typedef typename adaptor_type::result_type result_type; 923 924 /** Invokes the wrapped functor, ignoring the 6th argument. 925 * @param _A_a1 Argument to be passed on to the functor. 926 * @param _A_a2 Argument to be passed on to the functor. 927 * @param _A_a3 Argument to be passed on to the functor. 928 * @param _A_a4 Argument to be passed on to the functor. 929 * @param _A_a5 Argument to be passed on to the functor. 930 * @param _A_a6 Argument to be ignored. 931 * @return The return value of the functor invocation. 932 */ 933 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 934 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 935 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6) 936 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 937 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); } 938 939 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 940 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> 941 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type 942 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6) 943 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>> 944 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); } 945 #endif 946 947 /** Invokes the wrapped functor, ignoring the 6th argument. 948 * @param _A_a1 Argument to be passed on to the functor. 949 * @param _A_a2 Argument to be passed on to the functor. 950 * @param _A_a3 Argument to be passed on to the functor. 951 * @param _A_a4 Argument to be passed on to the functor. 952 * @param _A_a5 Argument to be passed on to the functor. 953 * @param _A_a6 Argument to be ignored. 954 * @param _A_a7 Argument to be passed on to the functor. 955 * @return The return value of the functor invocation. 956 */ 957 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 958 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 959 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7) 960 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>> 961 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); } 962 963 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 964 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 965 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 966 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7) 967 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>> 968 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); } 969 #endif 970 971 972 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 973 * @param _A_func Functor to invoke from operator()(). 974 */ 975 explicit hide_functor(const T_functor& _A_func) 976 : adapts<T_functor>(_A_func) 977 {} 978 }; 979 980 /** Adaptor that adds a dummy parameter to the wrapped functor. 981 * This template specialization ignores the value of the 7th parameter in operator()(). 982 * 983 * @ingroup hide 984 */ 985 template <class T_functor> 986 struct hide_functor <6, T_functor> : public adapts<T_functor> 987 { 988 typedef typename adapts<T_functor>::adaptor_type adaptor_type; 989 990 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> 991 struct deduce_result_type 992 { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; }; 993 typedef typename adaptor_type::result_type result_type; 994 995 /** Invokes the wrapped functor, ignoring the 7th argument. 996 * @param _A_a1 Argument to be passed on to the functor. 997 * @param _A_a2 Argument to be passed on to the functor. 998 * @param _A_a3 Argument to be passed on to the functor. 999 * @param _A_a4 Argument to be passed on to the functor. 1000 * @param _A_a5 Argument to be passed on to the functor. 1001 * @param _A_a6 Argument to be passed on to the functor. 1002 * @param _A_a7 Argument to be ignored. 1003 * @return The return value of the functor invocation. 1004 */ 1005 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 1006 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 1007 operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7) 1008 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 1009 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 1010 1011 #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 1012 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> 1013 typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type 1014 sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7) 1015 { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>> 1016 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); } 1017 #endif 1018 1019 1020 /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. 1021 * @param _A_func Functor to invoke from operator()(). 1022 */ 1023 explicit hide_functor(const T_functor& _A_func) 1024 : adapts<T_functor>(_A_func) 1025 {} 1026 }; 1027 #endif // DOXYGEN_SHOULD_SKIP_THIS 1028 1029 1030 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1031 //template specialization of visitor<>::do_visit_each<>(action, functor): 1032 /** Performs a functor on each of the targets of a functor. 1033 * The function overload for sigc::hide_functor performs a functor on the 1034 * functor stored in the sigc::hide_functor object. 1035 * 1036 * @ingroup hide 1037 */ 1038 template <int I_location, class T_functor> 1039 struct visitor<hide_functor<I_location, T_functor> > 1040 { 1041 template <typename T_action> 1042 static void do_visit_each(const T_action& _A_action, 1043 const hide_functor<I_location, T_functor>& _A_target) 1044 { 1045 sigc::visit_each(_A_action, _A_target.functor_); 1046 } 1047 }; 1048 #endif // DOXYGEN_SHOULD_SKIP_THIS 1049 1050 /** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor. 1051 * The optional template argument @e I_location specifies the zero-based 1052 * position of the dummy parameter in the returned functor (@p -1 stands for the last parameter). 1053 * 1054 * @param _A_func Functor that should be wrapped. 1055 * @return Adaptor that executes @e _A_func, ignoring the value of the dummy parameter. 1056 * 1057 * @ingroup hide 1058 */ 1059 template <int I_location, class T_functor> 1060 inline hide_functor<I_location, T_functor> 1061 hide(const T_functor& _A_func) 1062 { return hide_functor<I_location, T_functor>(_A_func); } 1063 1064 /** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor. 1065 * This overload adds a dummy parameter at the back of the functor's parameter list. 1066 * 1067 * @param _A_func Functor that should be wrapped. 1068 * @return Adaptor that executes @e _A_func, ignoring the value of the last parameter. 1069 * 1070 * @ingroup hide 1071 */ 1072 template <class T_functor> 1073 inline hide_functor<-1, T_functor> 1074 hide(const T_functor& _A_func) 1075 { return hide_functor<-1, T_functor> (_A_func); } 1076 1077 } /* namespace sigc */ 1078 #endif /* _SIGC_ADAPTORS_HIDE_H_ */ 1079