untracked/sigc++/adaptors/retype_return.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_RETYPE_RETURN_H_
   4 #define _SIGC_ADAPTORS_RETYPE_RETURN_H_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6
   7 namespace sigc {
   8
   9 /** Adaptor that performs a C-style cast on the return value of a functor.
  10  * Use the convenience function sigc::retype_return() to create an instance of retype_return_functor.
  11  *
  12  * The following template arguments are used:
  13  * - @e T_return Target type of the C-style cast.
  14  * - @e T_functor Type of the functor to wrap.
  15  *
  16  * @ingroup retype
  17  */
  18 template <class T_return, class T_functor>
  19 struct retype_return_functor : public adapts<T_functor>
  20 {
  21 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  22   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>
  23   struct deduce_result_type
  24     { typedef T_return type; };
  25 #endif
  26   typedef T_return result_type;
  27
  28   T_return operator()();
  29
  30   template <class T_arg1>
  31   inline T_return operator()(T_arg1 _A_a1)
  32     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
  33         (_A_a1));
  34     }
  35
  36   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  37   template <class T_arg1>
  38   inline T_return sun_forte_workaround(T_arg1 _A_a1)
  39     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
  40         (_A_a1));
  41     }
  42   #endif
  43
  44   template <class T_arg1, class T_arg2>
  45   inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2)
  46     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
  47         (_A_a1, _A_a2));
  48     }
  49
  50   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  51   template <class T_arg1, class T_arg2>
  52   inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
  53     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
  54         (_A_a1, _A_a2));
  55     }
  56   #endif
  57
  58   template <class T_arg1, class T_arg2, class T_arg3>
  59   inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
  60     { return T_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>>
  61         (_A_a1, _A_a2, _A_a3));
  62     }
  63
  64   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  65   template <class T_arg1, class T_arg2, class T_arg3>
  66   inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
  67     { return T_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>>
  68         (_A_a1, _A_a2, _A_a3));
  69     }
  70   #endif
  71
  72   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
  73   inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
  74     { return T_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>>
  75         (_A_a1, _A_a2, _A_a3, _A_a4));
  76     }
  77
  78   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  79   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
  80   inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
  81     { return T_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>>
  82         (_A_a1, _A_a2, _A_a3, _A_a4));
  83     }
  84   #endif
  85
  86   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
  87   inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
  88     { return T_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>>
  89         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
  90     }
  91
  92   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  93   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
  94   inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
  95     { return T_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>>
  96         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
  97     }
  98   #endif
  99
 100   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 101   inline T_return 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)
 102     { return T_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>>
 103         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
 104     }
 105
 106   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 107   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 108   inline T_return 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)
 109     { return T_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>>
 110         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
 111     }
 112   #endif
 113
 114   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 115   inline T_return 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 _A_a7)
 116     { return T_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>, type_trait_pass_t<T_arg7>>
 117         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
 118     }
 119
 120   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 121   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 122   inline T_return 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 _A_a7)
 123     { return T_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>, type_trait_pass_t<T_arg7>>
 124         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
 125     }
 126   #endif
 127
 128   retype_return_functor() {}
 129
 130   /** Constructs a retype_return_functor object that perform a C-style cast on the return value of the passed functor.
 131    * @param _A_functor Functor to invoke from operator()().
 132    */
 133   explicit retype_return_functor(type_trait_take_t<T_functor> _A_functor)
 134     : adapts<T_functor>(_A_functor)
 135     {}
 136 };
 137
 138 template <class T_return, class T_functor>
 139 T_return retype_return_functor<T_return, T_functor>::operator()()
 140   { return T_return(this->functor_()); }
 141
 142
 143 /** Adaptor that performs a C-style cast on the return value of a functor.
 144  * This template specialization is for a void return. It drops the return value of the functor it invokes.
 145  * Use the convenience function sigc::hide_return() to create an instance of sigc::retype_return_functor<void>.
 146  *
 147  * @ingroup retype
 148  */
 149 /* The void specialization is needed because of explicit cast to T_return.
 150  */
 151 template <class T_functor>
 152 struct retype_return_functor<void, T_functor> : public adapts<T_functor>
 153 {
 154 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 155   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>
 156   struct deduce_result_type
 157     { typedef void type; };
 158 #endif
 159   typedef void result_type;
 160
 161   void operator()();
 162
 163   template <class T_arg1>
 164   inline void operator()(T_arg1 _A_a1)
 165     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
 166         (_A_a1);
 167     }
 168
 169   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 170   template <class T_arg1>
 171   inline void sun_forte_workaround(T_arg1 _A_a1)
 172     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
 173         (_A_a1);
 174     }
 175   #endif
 176
 177   template <class T_arg1, class T_arg2>
 178   inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2)
 179     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 180         (_A_a1, _A_a2);
 181     }
 182
 183   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 184   template <class T_arg1, class T_arg2>
 185   inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
 186     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 187         (_A_a1, _A_a2);
 188     }
 189   #endif
 190
 191   template <class T_arg1, class T_arg2, class T_arg3>
 192   inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 193     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 194         (_A_a1, _A_a2, _A_a3);
 195     }
 196
 197   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 198   template <class T_arg1, class T_arg2, class T_arg3>
 199   inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 200     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 201         (_A_a1, _A_a2, _A_a3);
 202     }
 203   #endif
 204
 205   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 206   inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 207     { 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>>
 208         (_A_a1, _A_a2, _A_a3, _A_a4);
 209     }
 210
 211   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 212   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 213   inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 214     { 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>>
 215         (_A_a1, _A_a2, _A_a3, _A_a4);
 216     }
 217   #endif
 218
 219   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 220   inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 221     { 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>>
 222         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
 223     }
 224
 225   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 226   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 227   inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 228     { 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>>
 229         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
 230     }
 231   #endif
 232
 233   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 234   inline void 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)
 235     { 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>>
 236         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
 237     }
 238
 239   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 240   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 241   inline void 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)
 242     { 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>>
 243         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
 244     }
 245   #endif
 246
 247   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 248   inline void 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 _A_a7)
 249     { 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>, type_trait_pass_t<T_arg7>>
 250         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
 251     }
 252
 253   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 254   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 255   inline void 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 _A_a7)
 256     { 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>, type_trait_pass_t<T_arg7>>
 257         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
 258     }
 259   #endif
 260
 261   retype_return_functor() {}
 262   retype_return_functor(type_trait_take_t<T_functor> _A_functor)
 263     : adapts<T_functor>(_A_functor)
 264     {}
 265 };
 266
 267 template <class T_functor>
 268 void retype_return_functor<void, T_functor>::operator()()
 269   { this->functor_(); }
 270
 271 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 272 //template specialization of visitor<>::do_visit_each<>(action, functor):
 273 /** Performs a functor on each of the targets of a functor.
 274  * The function overload for sigc::retype_return_functor performs a functor on the
 275  * functor stored in the sigc::retype_return_functor object.
 276  *
 277  * @ingroup retype
 278  */
 279 template <class T_return, class T_functor>
 280 struct visitor<retype_return_functor<T_return, T_functor> >
 281 {
 282   template <typename T_action>
 283   static void do_visit_each(const T_action& _A_action,
 284                             const retype_return_functor<T_return, T_functor>& _A_target)
 285   {
 286     sigc::visit_each(_A_action, _A_target.functor_);
 287   }
 288 };
 289 #endif // DOXYGEN_SHOULD_SKIP_THIS
 290
 291 /** Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return value of the passed functor.
 292  * The template argument @e T_return specifies the target type of the cast.
 293  *
 294  * @param _A_functor Functor that should be wrapped.
 295  * @return Adaptor that executes @e _A_functor performing a C-style cast on the return value.
 296  *
 297  * @ingroup retype
 298  */
 299 template <class T_return, class T_functor>
 300 inline retype_return_functor<T_return, T_functor>
 301 retype_return(const T_functor& _A_functor)
 302   { return retype_return_functor<T_return, T_functor>(_A_functor); }
 303
 304 /** Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed functor.
 305  *
 306  * @param _A_functor Functor that should be wrapped.
 307  * @return Adaptor that executes @e _A_functor dropping its return value.
 308  *
 309  * @ingroup hide
 310  */
 311 template <class T_functor>
 312 inline retype_return_functor<void, T_functor>
 313 hide_return(const T_functor& _A_functor)
 314   { return retype_return_functor<void, T_functor>(_A_functor); }
 315
 316 } /* namespace sigc */
 317 #endif /* _SIGC_ADAPTORS_RETYPE_RETURN_H_ */