libs/sigc++2/sigc++/adaptors/bind_return.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
   4 #define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6 #include <sigc++/adaptors/bound_argument.h>
   7
   8 namespace sigc {
   9
  10 /** Adaptor that fixes the return value of the wrapped functor.
  11  * Use the convenience function sigc::bind_return() to create an instance of sigc::bind_return_functor.
  12  *
  13  * The following template arguments are used:
  14  * - @e T_return Type of the fixed return value.
  15  * - @e T_functor Type of the functor to wrap.
  16  *
  17  * @ingroup bind
  18  */
  19 template <class T_return, class T_functor>
  20 struct bind_return_functor : public adapts<T_functor>
  21 {
  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 typename unwrap_reference<T_return>::type type; };
  25   typedef typename unwrap_reference<T_return>::type result_type;
  26
  27   /** Invokes the wrapped functor dropping its return value.
  28    * @return The fixed return value.
  29    */
  30   typename unwrap_reference<T_return>::type operator()();
  31
  32   /** Invokes the wrapped functor passing on the arguments.,
  33    * @param _A_arg%1 Argument to be passed on to the functor.)
  34    * @return The fixed return value.
  35    */
  36   template <class T_arg1>
  37   inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1)
  38     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
  39         (_A_a1); return ret_value_.invoke();
  40     }
  41
  42   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  43   template <class T_arg1>
  44   inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1)
  45     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
  46         (_A_a1); return ret_value_.invoke();
  47     }
  48   #endif
  49
  50   /** Invokes the wrapped functor passing on the arguments.,
  51    * @param _A_arg%1 Argument to be passed on to the functor.)
  52    * @return The fixed return value.
  53    */
  54   template <class T_arg1,class T_arg2>
  55   inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2)
  56     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
  57         (_A_a1,_A_a2); return ret_value_.invoke();
  58     }
  59
  60   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  61   template <class T_arg1,class T_arg2>
  62   inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
  63     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
  64         (_A_a1,_A_a2); return ret_value_.invoke();
  65     }
  66   #endif
  67
  68   /** Invokes the wrapped functor passing on the arguments.,
  69    * @param _A_arg%1 Argument to be passed on to the functor.)
  70    * @return The fixed return value.
  71    */
  72   template <class T_arg1,class T_arg2,class T_arg3>
  73   inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
  74     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
  75         (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
  76     }
  77
  78   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  79   template <class T_arg1,class T_arg2,class T_arg3>
  80   inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
  81     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
  82         (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
  83     }
  84   #endif
  85
  86   /** Invokes the wrapped functor passing on the arguments.,
  87    * @param _A_arg%1 Argument to be passed on to the functor.)
  88    * @return The fixed return value.
  89    */
  90   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
  91   inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
  92     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
  93         (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
  94     }
  95
  96   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  97   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
  98   inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
  99     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
 100         (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
 101     }
 102   #endif
 103
 104   /** Invokes the wrapped functor passing on the arguments.,
 105    * @param _A_arg%1 Argument to be passed on to the functor.)
 106    * @return The fixed return value.
 107    */
 108   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 109   inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 110     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
 111         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
 112     }
 113
 114   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 115   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 116   inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 117     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
 118         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
 119     }
 120   #endif
 121
 122   /** Invokes the wrapped functor passing on the arguments.,
 123    * @param _A_arg%1 Argument to be passed on to the functor.)
 124    * @return The fixed return value.
 125    */
 126   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 127   inline typename unwrap_reference<T_return>::type 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)
 128     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
 129         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
 130     }
 131
 132   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 133   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 134   inline typename unwrap_reference<T_return>::type 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)
 135     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
 136         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
 137     }
 138   #endif
 139
 140   /** Invokes the wrapped functor passing on the arguments.,
 141    * @param _A_arg%1 Argument to be passed on to the functor.)
 142    * @return The fixed return value.
 143    */
 144   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 145   inline typename unwrap_reference<T_return>::type 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)
 146     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
 147         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
 148     }
 149
 150   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 151   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 152   inline typename unwrap_reference<T_return>::type 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)
 153     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
 154         (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
 155     }
 156   #endif
 157
 158
 159   /** Constructs a bind_return_functor object that fixes the return value to @p _A_ret_value.
 160    * @param _A_functor Functor to invoke from operator()().
 161    * @param _A_ret_value Value to return from operator()().
 162    */
 163   bind_return_functor(typename type_trait<T_functor>::take _A_functor, typename type_trait<T_return>::take _A_ret_value)
 164     : adapts<T_functor>(_A_functor), ret_value_(_A_ret_value)
 165     {}
 166
 167   /// The fixed return value.
 168   bound_argument<T_return> ret_value_; // public, so that visit_each() can access it
 169 };
 170
 171 template <class T_return, class T_functor>
 172 typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_functor>::operator()()
 173   { this->functor_(); return ret_value_.invoke(); }
 174
 175
 176 //template specialization of visit_each<>(action, functor):
 177 /** Performs a functor on each of the targets of a functor.
 178  * The function overload for sigc::bind_return_functor performs a functor on the
 179  * functor and on the object instance stored in the sigc::bind_return_functor object.
 180  *
 181  * @ingroup bind
 182  */
 183 template <class T_action, class T_return, class T_functor>
 184 void visit_each(const T_action& _A_action,
 185                 const bind_return_functor<T_return, T_functor>& _A_target)
 186 {
 187   visit_each(_A_action, _A_target.ret_value_);
 188   visit_each(_A_action, _A_target.functor_);
 189 }
 190
 191
 192 /** Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument.
 193  *
 194  * @param _A_functor Functor that should be wrapped.
 195  * @param _A_ret_value Argument to fix the return value of @e _A_functor to.
 196  * @return Adaptor that executes @e _A_functor on invokation and returns @e _A_ret_value.
 197  *
 198  * @ingroup bind
 199  */
 200 template <class T_return, class T_functor>
 201 inline bind_return_functor<T_return, T_functor>
 202 bind_return(const T_functor& _A_functor, T_return _A_ret_value)
 203 { return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
 204
 205 } /* namespace sigc */
 206 #endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */