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

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
   4 #define _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
   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::execption_catch() returns can be passed into
  48  * sigc::signal::connect() directly.
  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   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>
  65   struct deduce_result_type
  66     { typedef typename adaptor_type::template deduce_result_type<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>::type type; };
  67   typedef T_return result_type;
  68
  69   result_type
  70   operator()();
  71
  72   template <class T_arg1>
  73   typename deduce_result_type<T_arg1>::type
  74   operator()(T_arg1 _A_a1)
  75     {
  76       try
  77         {
  78           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
  79             (_A_a1);
  80         }
  81       catch (...)
  82         { return catcher_(); }
  83     }
  84
  85   template <class T_arg1,class T_arg2>
  86   typename deduce_result_type<T_arg1,T_arg2>::type
  87   operator()(T_arg1 _A_a1,T_arg2 _A_a2)
  88     {
  89       try
  90         {
  91           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
  92             (_A_a1,_A_a2);
  93         }
  94       catch (...)
  95         { return catcher_(); }
  96     }
  97
  98   template <class T_arg1,class T_arg2,class T_arg3>
  99   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
 100   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
 101     {
 102       try
 103         {
 104           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
 105             (_A_a1,_A_a2,_A_a3);
 106         }
 107       catch (...)
 108         { return catcher_(); }
 109     }
 110
 111   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 112   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
 113   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
 114     {
 115       try
 116         {
 117           return 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>
 118             (_A_a1,_A_a2,_A_a3,_A_a4);
 119         }
 120       catch (...)
 121         { return catcher_(); }
 122     }
 123
 124   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 125   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
 126   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 127     {
 128       try
 129         {
 130           return 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>
 131             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
 132         }
 133       catch (...)
 134         { return catcher_(); }
 135     }
 136
 137   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 138   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
 139   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)
 140     {
 141       try
 142         {
 143           return 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>
 144             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
 145         }
 146       catch (...)
 147         { return catcher_(); }
 148     }
 149
 150   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 151   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
 152   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)
 153     {
 154       try
 155         {
 156           return 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>
 157             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
 158         }
 159       catch (...)
 160         { return catcher_(); }
 161     }
 162
 163   exception_catch_functor(const T_functor& _A_func,
 164                           const T_catcher& _A_catcher)
 165     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
 166     {}
 167
 168   protected:
 169     T_catcher catcher_;
 170 };
 171
 172 template <class T_functor, class T_catcher, class T_return>
 173 typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
 174 exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
 175   {
 176     try
 177       { return this->functor_(); }
 178     catch (...)
 179       { return catcher_(); }
 180   }
 181
 182 // void specialization
 183 template <class T_functor, class T_catcher>
 184 struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
 185 {
 186   typedef void result_type;
 187   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 188
 189   void
 190   operator()();
 191
 192   template <class T_arg1>
 193   typename deduce_result_type<T_arg1>::type
 194   operator()(T_arg1 _A_a1)
 195     {
 196       try
 197         {
 198           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
 199             (_A_a1);
 200         }
 201       catch (...)
 202         { return catcher_(); }
 203     }
 204
 205   template <class T_arg1,class T_arg2>
 206   typename deduce_result_type<T_arg1,T_arg2>::type
 207   operator()(T_arg1 _A_a1,T_arg2 _A_a2)
 208     {
 209       try
 210         {
 211           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
 212             (_A_a1,_A_a2);
 213         }
 214       catch (...)
 215         { return catcher_(); }
 216     }
 217
 218   template <class T_arg1,class T_arg2,class T_arg3>
 219   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
 220   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
 221     {
 222       try
 223         {
 224           return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
 225             (_A_a1,_A_a2,_A_a3);
 226         }
 227       catch (...)
 228         { return catcher_(); }
 229     }
 230
 231   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 232   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
 233   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
 234     {
 235       try
 236         {
 237           return 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>
 238             (_A_a1,_A_a2,_A_a3,_A_a4);
 239         }
 240       catch (...)
 241         { return catcher_(); }
 242     }
 243
 244   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 245   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
 246   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 247     {
 248       try
 249         {
 250           return 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>
 251             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
 252         }
 253       catch (...)
 254         { return catcher_(); }
 255     }
 256
 257   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 258   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
 259   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)
 260     {
 261       try
 262         {
 263           return 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>
 264             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
 265         }
 266       catch (...)
 267         { return catcher_(); }
 268     }
 269
 270   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 271   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
 272   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)
 273     {
 274       try
 275         {
 276           return 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>
 277             (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
 278         }
 279       catch (...)
 280         { return catcher_(); }
 281     }
 282
 283   exception_catch_functor() {}
 284   exception_catch_functor(const T_functor& _A_func,
 285                           const T_catcher& _A_catcher)
 286     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
 287     {}
 288   ~exception_catch_functor() {}
 289
 290   protected:
 291     T_catcher catcher_;
 292 };
 293
 294 template <class T_functor, class T_catcher>
 295 void exception_catch_functor<T_functor, T_catcher, void>::operator()()
 296   {
 297     try
 298       { this->functor_(); } // I don't understand why void return doesn't work here (Martin)
 299     catch (...)
 300       { this->catcher_(); }
 301   }
 302
 303
 304 template <class T_action, class T_functor, class T_catcher, class T_return>
 305 void visit_each(const T_action& _A_action,
 306                 const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
 307 {
 308   visit_each(_A_action, _A_target.functor_);
 309   visit_each(_A_action, _A_target.catcher_);
 310 }
 311
 312
 313 template <class T_functor, class T_catcher>
 314 inline exception_catch_functor<T_functor, T_catcher>
 315 exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
 316   { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
 317
 318 } /* namespace sigc */
 319 #endif /* _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_ */