untracked/sigc++/adaptors/hide.h

   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_ */