untracked/sigc++/adaptors/bind_return.h

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