untracked/sigc++/adaptors/exception_catch.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
   4 #define _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6
   7 namespace sigc {
   8
   9 /*
  10    functor adaptor:  exception_catch(functor, catcher)
  11
  12    usage:
  13
  14
  15    Future directions:
  16      The catcher should be told what type of return it needs to
  17    return for multiple type functors,  to do this the user
  18    will need to derive from catcher_base.
  19 */
  20 /** @defgroup exception_catch exception_catch()
  21  * sigc::exception_catch() catches an exception thrown from within
  22  * the wrapped functor and directs it to a catcher functor.
  23  * This catcher can then rethrow the exception and catch it with the proper type.
  24  *
  25  * Note that the catcher is expected to return the same type
  26  * as the wrapped functor so that normal flow can continue.
  27  *
  28  * Catchers can be cascaded to catch multiple types, because uncaught
  29  * rethrown exceptions proceed to the next catcher adaptor.
  30  *
  31  * @par Examples:
  32  * @code
  33  * struct my_catch
  34  * {
  35  *   int operator()()
  36  *   {
  37  *     try { throw; }
  38  *     catch (std::range_error e) // catch what types we know
  39  *       { std::cerr << "caught " << e.what() << std::endl; }
  40  *     return 1;
  41  *   }
  42  * }
  43  * int foo(); // throws std::range_error
  44  * sigc::exception_catch(&foo, my_catch())();
  45  * @endcode
  46  *
  47  * The functor sigc::exception_catch() returns can be directly passed into
  48  * sigc::signal::connect().
  49  *
  50  * @par Example:
  51  * @code
  52  * sigc::signal<int> some_signal;
  53  * some_signal.connect(sigc::exception_catch(&foo, my_catch));
  54  * @endcode
  55  *
  56  * @ingroup adaptors
  57  */
  58
  59 template <class T_functor, class T_catcher, class T_return = typename adapts<T_functor>::result_type>
  60 struct exception_catch_functor : public adapts<T_functor>
  61 {
  62   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
  63
  64 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  65   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>
  66   struct deduce_result_type
  67     { 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_trait_pass_t<T_arg7>>::type type; };
  68 #endif
  69   typedef T_return result_type;
  70
  71   result_type
  72   operator()();
  73
  74   template <class T_arg1>
  75   typename deduce_result_type<T_arg1>::type
  76   operator()(T_arg1 _A_a1)
  77     {
  78       try
  79         {
  80           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
  81             (_A_a1);
  82         }
  83       catch (...)
  84         { return catcher_(); }
  85     }
  86
  87   template <class T_arg1, class T_arg2>
  88   typename deduce_result_type<T_arg1, T_arg2>::type
  89   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
  90     {
  91       try
  92         {
  93           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
  94             (_A_a1, _A_a2);
  95         }
  96       catch (...)
  97         { return catcher_(); }
  98     }
  99
 100   template <class T_arg1, class T_arg2, class T_arg3>
 101   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 102   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 103     {
 104       try
 105         {
 106           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>>
 107             (_A_a1, _A_a2, _A_a3);
 108         }
 109       catch (...)
 110         { return catcher_(); }
 111     }
 112
 113   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 114   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 115   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 116     {
 117       try
 118         {
 119           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>>
 120             (_A_a1, _A_a2, _A_a3, _A_a4);
 121         }
 122       catch (...)
 123         { return catcher_(); }
 124     }
 125
 126   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 127   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 128   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 129     {
 130       try
 131         {
 132           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>>
 133             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
 134         }
 135       catch (...)
 136         { return catcher_(); }
 137     }
 138
 139   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 140   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 141   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)
 142     {
 143       try
 144         {
 145           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>>
 146             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
 147         }
 148       catch (...)
 149         { return catcher_(); }
 150     }
 151
 152   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 153   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 154   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)
 155     {
 156       try
 157         {
 158           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>>
 159             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
 160         }
 161       catch (...)
 162         { return catcher_(); }
 163     }
 164
 165   exception_catch_functor(const T_functor& _A_func,
 166                           const T_catcher& _A_catcher)
 167     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
 168     {}
 169
 170   T_catcher catcher_;
 171 };
 172
 173 template <class T_functor, class T_catcher, class T_return>
 174 typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
 175 exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
 176   {
 177     try
 178       { return this->functor_(); }
 179     catch (...)
 180       { return catcher_(); }
 181   }
 182
 183 // void specialization
 184 template <class T_functor, class T_catcher>
 185 struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
 186 {
 187   typedef void result_type;
 188   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 189
 190 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 191   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>
 192   struct deduce_result_type
 193     { 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_trait_pass_t<T_arg7>>::type type; };
 194 #endif
 195
 196   void
 197   operator()();
 198
 199   template <class T_arg1>
 200   typename deduce_result_type<T_arg1>::type
 201   operator()(T_arg1 _A_a1)
 202     {
 203       try
 204         {
 205           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
 206             (_A_a1);
 207         }
 208       catch (...)
 209         { return catcher_(); }
 210     }
 211
 212   template <class T_arg1, class T_arg2>
 213   typename deduce_result_type<T_arg1, T_arg2>::type
 214   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
 215     {
 216       try
 217         {
 218           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 219             (_A_a1, _A_a2);
 220         }
 221       catch (...)
 222         { return catcher_(); }
 223     }
 224
 225   template <class T_arg1, class T_arg2, class T_arg3>
 226   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 227   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 228     {
 229       try
 230         {
 231           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>>
 232             (_A_a1, _A_a2, _A_a3);
 233         }
 234       catch (...)
 235         { return catcher_(); }
 236     }
 237
 238   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 239   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 240   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 241     {
 242       try
 243         {
 244           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>>
 245             (_A_a1, _A_a2, _A_a3, _A_a4);
 246         }
 247       catch (...)
 248         { return catcher_(); }
 249     }
 250
 251   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 252   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 253   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 254     {
 255       try
 256         {
 257           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>>
 258             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
 259         }
 260       catch (...)
 261         { return catcher_(); }
 262     }
 263
 264   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 265   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 266   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)
 267     {
 268       try
 269         {
 270           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>>
 271             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
 272         }
 273       catch (...)
 274         { return catcher_(); }
 275     }
 276
 277   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 278   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 279   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)
 280     {
 281       try
 282         {
 283           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>>
 284             (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
 285         }
 286       catch (...)
 287         { return catcher_(); }
 288     }
 289
 290   exception_catch_functor() {}
 291   exception_catch_functor(const T_functor& _A_func,
 292                           const T_catcher& _A_catcher)
 293     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
 294     {}
 295   ~exception_catch_functor() {}
 296
 297     T_catcher catcher_;
 298 };
 299
 300 template <class T_functor, class T_catcher>
 301 void exception_catch_functor<T_functor, T_catcher, void>::operator()()
 302   {
 303     try
 304       { this->functor_(); } // I don't understand why void return doesn't work here (Martin)
 305     catch (...)
 306       { this->catcher_(); }
 307   }
 308
 309 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 310 //template specialization of visitor<>::do_visit_each<>(action, functor):
 311 template <class T_functor, class T_catcher, class T_return>
 312 struct visitor<exception_catch_functor<T_functor, T_catcher, T_return> >
 313 {
 314   template <typename T_action>
 315   static void do_visit_each(const T_action& _A_action,
 316                             const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
 317   {
 318     sigc::visit_each(_A_action, _A_target.functor_);
 319     sigc::visit_each(_A_action, _A_target.catcher_);
 320   }
 321 };
 322 #endif // DOXYGEN_SHOULD_SKIP_THIS
 323
 324 template <class T_functor, class T_catcher>
 325 inline exception_catch_functor<T_functor, T_catcher>
 326 exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
 327   { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
 328
 329 } /* namespace sigc */
 330 #endif /* _SIGC_ADAPTORS_EXCEPTION_CATCH_H_ */