untracked/sigc++/adaptors/track_obj.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_TRACK_OBJ_H_
   4 #define _SIGC_ADAPTORS_TRACK_OBJ_H_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6 #include <sigc++/limit_reference.h>
   7
   8 namespace sigc {
   9
  10 /** @defgroup track_obj track_obj()
  11  * sigc::track_obj() tracks trackable objects, referenced from a functor.
  12  * It can be useful when you assign a C++11 lambda expression or a std::function<>
  13  * to a slot, or connect it to a signal, and the lambda expression or std::function<>
  14  * contains references to sigc::trackable derived objects.
  15  *
  16  * The functor returned by sigc::track_obj() is formally an adaptor, but it does
  17  * not alter the signature, return type or behaviour of the supplied functor.
  18  * Up to 7 objects can be tracked. operator()() can have up to 7 arguments.
  19  *
  20  * @par Example:
  21  * @code
  22  * struct bar : public sigc::trackable {};
  23  * sigc::signal<void> some_signal;
  24  * void foo(bar&);
  25  * {
  26  *   bar some_bar;
  27  *   some_signal.connect([&some_bar](){ foo(some_bar); });
  28  *     // NOT disconnected automatically when some_bar goes out of scope
  29  *   some_signal.connect(sigc::track_obj([&some_bar](){ foo(some_bar); }, some_bar);
  30  *     // disconnected automatically when some_bar goes out of scope
  31  * }
  32  * @endcode
  33  *
  34  * @newin{2,4}
  35  *
  36  * @ingroup adaptors
  37  */
  38
  39 /** track_obj_functor1 wraps a functor and stores a reference to a trackable object.
  40  * Use the convenience function track_obj() to create an instance of track_obj_functor1.
  41  *
  42  * @tparam T_functor The type of functor to wrap.
  43  * @tparam T_obj1 The type of a trackable object.
  44  *
  45  * @newin{2,4}
  46  *
  47  * @ingroup track_obj
  48  */
  49 template <typename T_functor, typename T_obj1>
  50 class track_obj_functor1 : public adapts<T_functor>
  51 {
  52 public:
  53   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
  54
  55 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  56   template <typename T_arg1=void, typename T_arg2=void, typename T_arg3=void, typename T_arg4=void, typename T_arg5=void, typename T_arg6=void, typename T_arg7=void>
  57   struct deduce_result_type
  58     { 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; };
  59 #endif
  60   typedef typename adaptor_type::result_type result_type;
  61
  62   /** Constructs a track_obj_functor1 object that wraps the passed functor and
  63    * stores a reference to the passed trackable object.
  64    * @param _A_func Functor.
  65    * @param _A_obj1 Trackable object.
  66    */
  67   track_obj_functor1(const T_functor& _A_func, const T_obj1& _A_obj1)
  68   : adapts<T_functor>(_A_func), obj1_(_A_obj1) {}
  69
  70   /** Invokes the wrapped functor.
  71    * @return The return value of the functor invocation.
  72    */
  73   result_type operator()()
  74   { return this->functor_(); }
  75
  76   /** Invokes the wrapped functor passing on the arguments.
  77    * @param _A_arg1 Argument to be passed on to the functor.
  78    * @return The return value of the functor invocation.
  79    */
  80   template <typename T_arg1>
  81   typename deduce_result_type<T_arg1>::type
  82   operator()(T_arg1 _A_arg1)
  83   {
  84     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
  85       type_trait_pass_t<T_arg1>>
  86       (_A_arg1);
  87   }
  88
  89   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  90   template <typename T_arg1>
  91   typename deduce_result_type<T_arg1>::type
  92   sun_forte_workaround(T_arg1 _A_arg1)
  93   {
  94     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
  95       type_trait_pass_t<T_arg1>>
  96       (_A_arg1);
  97   }
  98   #endif
  99
 100   /** Invokes the wrapped functor passing on the arguments.
 101    * @param _A_arg1 Argument to be passed on to the functor.
 102    * @param _A_arg2 Argument to be passed on to the functor.
 103    * @return The return value of the functor invocation.
 104    */
 105   template <typename T_arg1, typename T_arg2>
 106   typename deduce_result_type<T_arg1, T_arg2>::type
 107   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
 108   {
 109     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 110       type_trait_pass_t<T_arg1>,
 111       type_trait_pass_t<T_arg2>>
 112       (_A_arg1, _A_arg2);
 113   }
 114
 115   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 116   template <typename T_arg1, typename T_arg2>
 117   typename deduce_result_type<T_arg1, T_arg2>::type
 118   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
 119   {
 120     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 121       type_trait_pass_t<T_arg1>,
 122       type_trait_pass_t<T_arg2>>
 123       (_A_arg1, _A_arg2);
 124   }
 125   #endif
 126
 127   /** Invokes the wrapped functor passing on the arguments.
 128    * @param _A_arg1 Argument to be passed on to the functor.
 129    * @param _A_arg2 Argument to be passed on to the functor.
 130    * @param _A_arg3 Argument to be passed on to the functor.
 131    * @return The return value of the functor invocation.
 132    */
 133   template <typename T_arg1, typename T_arg2, typename T_arg3>
 134   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 135   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 136   {
 137     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 138       type_trait_pass_t<T_arg1>,
 139       type_trait_pass_t<T_arg2>,
 140       type_trait_pass_t<T_arg3>>
 141       (_A_arg1, _A_arg2, _A_arg3);
 142   }
 143
 144   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 145   template <typename T_arg1, typename T_arg2, typename T_arg3>
 146   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 147   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 148   {
 149     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 150       type_trait_pass_t<T_arg1>,
 151       type_trait_pass_t<T_arg2>,
 152       type_trait_pass_t<T_arg3>>
 153       (_A_arg1, _A_arg2, _A_arg3);
 154   }
 155   #endif
 156
 157   /** Invokes the wrapped functor passing on the arguments.
 158    * @param _A_arg1 Argument to be passed on to the functor.
 159    * @param _A_arg2 Argument to be passed on to the functor.
 160    * @param _A_arg3 Argument to be passed on to the functor.
 161    * @param _A_arg4 Argument to be passed on to the functor.
 162    * @return The return value of the functor invocation.
 163    */
 164   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
 165   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 166   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 167   {
 168     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 169       type_trait_pass_t<T_arg1>,
 170       type_trait_pass_t<T_arg2>,
 171       type_trait_pass_t<T_arg3>,
 172       type_trait_pass_t<T_arg4>>
 173       (_A_arg1, _A_arg2, _A_arg3, _A_arg4);
 174   }
 175
 176   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 177   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
 178   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 179   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 180   {
 181     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 182       type_trait_pass_t<T_arg1>,
 183       type_trait_pass_t<T_arg2>,
 184       type_trait_pass_t<T_arg3>,
 185       type_trait_pass_t<T_arg4>>
 186       (_A_arg1, _A_arg2, _A_arg3, _A_arg4);
 187   }
 188   #endif
 189
 190   /** Invokes the wrapped functor passing on the arguments.
 191    * @param _A_arg1 Argument to be passed on to the functor.
 192    * @param _A_arg2 Argument to be passed on to the functor.
 193    * @param _A_arg3 Argument to be passed on to the functor.
 194    * @param _A_arg4 Argument to be passed on to the functor.
 195    * @param _A_arg5 Argument to be passed on to the functor.
 196    * @return The return value of the functor invocation.
 197    */
 198   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
 199   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 200   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 201   {
 202     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 203       type_trait_pass_t<T_arg1>,
 204       type_trait_pass_t<T_arg2>,
 205       type_trait_pass_t<T_arg3>,
 206       type_trait_pass_t<T_arg4>,
 207       type_trait_pass_t<T_arg5>>
 208       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 209   }
 210
 211   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 212   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
 213   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 214   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 215   {
 216     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 217       type_trait_pass_t<T_arg1>,
 218       type_trait_pass_t<T_arg2>,
 219       type_trait_pass_t<T_arg3>,
 220       type_trait_pass_t<T_arg4>,
 221       type_trait_pass_t<T_arg5>>
 222       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 223   }
 224   #endif
 225
 226   /** Invokes the wrapped functor passing on the arguments.
 227    * @param _A_arg1 Argument to be passed on to the functor.
 228    * @param _A_arg2 Argument to be passed on to the functor.
 229    * @param _A_arg3 Argument to be passed on to the functor.
 230    * @param _A_arg4 Argument to be passed on to the functor.
 231    * @param _A_arg5 Argument to be passed on to the functor.
 232    * @param _A_arg6 Argument to be passed on to the functor.
 233    * @return The return value of the functor invocation.
 234    */
 235   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
 236   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 237   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 238   {
 239     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 240       type_trait_pass_t<T_arg1>,
 241       type_trait_pass_t<T_arg2>,
 242       type_trait_pass_t<T_arg3>,
 243       type_trait_pass_t<T_arg4>,
 244       type_trait_pass_t<T_arg5>,
 245       type_trait_pass_t<T_arg6>>
 246       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 247   }
 248
 249   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 250   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
 251   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 252   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 253   {
 254     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 255       type_trait_pass_t<T_arg1>,
 256       type_trait_pass_t<T_arg2>,
 257       type_trait_pass_t<T_arg3>,
 258       type_trait_pass_t<T_arg4>,
 259       type_trait_pass_t<T_arg5>,
 260       type_trait_pass_t<T_arg6>>
 261       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 262   }
 263   #endif
 264
 265   /** Invokes the wrapped functor passing on the arguments.
 266    * @param _A_arg1 Argument to be passed on to the functor.
 267    * @param _A_arg2 Argument to be passed on to the functor.
 268    * @param _A_arg3 Argument to be passed on to the functor.
 269    * @param _A_arg4 Argument to be passed on to the functor.
 270    * @param _A_arg5 Argument to be passed on to the functor.
 271    * @param _A_arg6 Argument to be passed on to the functor.
 272    * @param _A_arg7 Argument to be passed on to the functor.
 273    * @return The return value of the functor invocation.
 274    */
 275   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
 276   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 277   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)
 278   {
 279     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 280       type_trait_pass_t<T_arg1>,
 281       type_trait_pass_t<T_arg2>,
 282       type_trait_pass_t<T_arg3>,
 283       type_trait_pass_t<T_arg4>,
 284       type_trait_pass_t<T_arg5>,
 285       type_trait_pass_t<T_arg6>,
 286       type_trait_pass_t<T_arg7>>
 287       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
 288   }
 289
 290   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 291   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
 292   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 293   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)
 294   {
 295     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
 296       type_trait_pass_t<T_arg1>,
 297       type_trait_pass_t<T_arg2>,
 298       type_trait_pass_t<T_arg3>,
 299       type_trait_pass_t<T_arg4>,
 300       type_trait_pass_t<T_arg5>,
 301       type_trait_pass_t<T_arg6>,
 302       type_trait_pass_t<T_arg7>>
 303       (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
 304   }
 305   #endif
 306
 307
 308 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 309 //protected:
 310   // public, so that visit_each() can access it.
 311   const_limit_reference<T_obj1> obj1_;
 312 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 313
 314 }; // end class track_obj_functor1
 315
 316 /** track_obj_functor2 wraps a functor and stores 2 references to trackable objects.
 317  * Use the convenience function track_obj() to create an instance of track_obj_functor2.
 318  *
 319  * @tparam T_functor The type of functor to wrap.
 320  * @tparam T_obj1 The type of a trackable object.
 321  * @tparam T_obj2 The type of a trackable object.
 322  *
 323  * @newin{2,4}
 324  *
 325  * @ingroup track_obj
 326  */
 327 template <typename T_functor, typename T_obj1, typename T_obj2>
 328 class track_obj_functor2 : public track_obj_functor1<T_functor, T_obj1>
 329 {
 330 public:
 331   /** Constructs a track_obj_functor2 object that wraps the passed functor and
 332    * stores references to the passed trackable objects.
 333    * @param _A_func Functor.
 334    * @param _A_obj1 Trackable object.
 335    * @param _A_obj2 Trackable object.
 336    */
 337   track_obj_functor2(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2)
 338   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2) {}
 339
 340 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 341 //protected:
 342   // public, so that visit_each() can access it.
 343   const_limit_reference<T_obj2> obj2_;
 344 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 345
 346 }; // end class track_obj_functor2
 347
 348 /** track_obj_functor3 wraps a functor and stores 3 references to trackable objects.
 349  * Use the convenience function track_obj() to create an instance of track_obj_functor3.
 350  *
 351  * @tparam T_functor The type of functor to wrap.
 352  * @tparam T_obj1 The type of a trackable object.
 353  * @tparam T_obj2 The type of a trackable object.
 354  * @tparam T_obj3 The type of a trackable object.
 355  *
 356  * @newin{2,4}
 357  *
 358  * @ingroup track_obj
 359  */
 360 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
 361 class track_obj_functor3 : public track_obj_functor1<T_functor, T_obj1>
 362 {
 363 public:
 364   /** Constructs a track_obj_functor3 object that wraps the passed functor and
 365    * stores references to the passed trackable objects.
 366    * @param _A_func Functor.
 367    * @param _A_obj1 Trackable object.
 368    * @param _A_obj2 Trackable object.
 369    * @param _A_obj3 Trackable object.
 370    */
 371   track_obj_functor3(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3)
 372   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3) {}
 373
 374 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 375 //protected:
 376   // public, so that visit_each() can access it.
 377   const_limit_reference<T_obj2> obj2_;
 378   const_limit_reference<T_obj3> obj3_;
 379 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 380
 381 }; // end class track_obj_functor3
 382
 383 /** track_obj_functor4 wraps a functor and stores 4 references to trackable objects.
 384  * Use the convenience function track_obj() to create an instance of track_obj_functor4.
 385  *
 386  * @tparam T_functor The type of functor to wrap.
 387  * @tparam T_obj1 The type of a trackable object.
 388  * @tparam T_obj2 The type of a trackable object.
 389  * @tparam T_obj3 The type of a trackable object.
 390  * @tparam T_obj4 The type of a trackable object.
 391  *
 392  * @newin{2,4}
 393  *
 394  * @ingroup track_obj
 395  */
 396 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
 397 class track_obj_functor4 : public track_obj_functor1<T_functor, T_obj1>
 398 {
 399 public:
 400   /** Constructs a track_obj_functor4 object that wraps the passed functor and
 401    * stores references to the passed trackable objects.
 402    * @param _A_func Functor.
 403    * @param _A_obj1 Trackable object.
 404    * @param _A_obj2 Trackable object.
 405    * @param _A_obj3 Trackable object.
 406    * @param _A_obj4 Trackable object.
 407    */
 408   track_obj_functor4(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4)
 409   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4) {}
 410
 411 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 412 //protected:
 413   // public, so that visit_each() can access it.
 414   const_limit_reference<T_obj2> obj2_;
 415   const_limit_reference<T_obj3> obj3_;
 416   const_limit_reference<T_obj4> obj4_;
 417 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 418
 419 }; // end class track_obj_functor4
 420
 421 /** track_obj_functor5 wraps a functor and stores 5 references to trackable objects.
 422  * Use the convenience function track_obj() to create an instance of track_obj_functor5.
 423  *
 424  * @tparam T_functor The type of functor to wrap.
 425  * @tparam T_obj1 The type of a trackable object.
 426  * @tparam T_obj2 The type of a trackable object.
 427  * @tparam T_obj3 The type of a trackable object.
 428  * @tparam T_obj4 The type of a trackable object.
 429  * @tparam T_obj5 The type of a trackable object.
 430  *
 431  * @newin{2,4}
 432  *
 433  * @ingroup track_obj
 434  */
 435 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
 436 class track_obj_functor5 : public track_obj_functor1<T_functor, T_obj1>
 437 {
 438 public:
 439   /** Constructs a track_obj_functor5 object that wraps the passed functor and
 440    * stores references to the passed trackable objects.
 441    * @param _A_func Functor.
 442    * @param _A_obj1 Trackable object.
 443    * @param _A_obj2 Trackable object.
 444    * @param _A_obj3 Trackable object.
 445    * @param _A_obj4 Trackable object.
 446    * @param _A_obj5 Trackable object.
 447    */
 448   track_obj_functor5(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5)
 449   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5) {}
 450
 451 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 452 //protected:
 453   // public, so that visit_each() can access it.
 454   const_limit_reference<T_obj2> obj2_;
 455   const_limit_reference<T_obj3> obj3_;
 456   const_limit_reference<T_obj4> obj4_;
 457   const_limit_reference<T_obj5> obj5_;
 458 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 459
 460 }; // end class track_obj_functor5
 461
 462 /** track_obj_functor6 wraps a functor and stores 6 references to trackable objects.
 463  * Use the convenience function track_obj() to create an instance of track_obj_functor6.
 464  *
 465  * @tparam T_functor The type of functor to wrap.
 466  * @tparam T_obj1 The type of a trackable object.
 467  * @tparam T_obj2 The type of a trackable object.
 468  * @tparam T_obj3 The type of a trackable object.
 469  * @tparam T_obj4 The type of a trackable object.
 470  * @tparam T_obj5 The type of a trackable object.
 471  * @tparam T_obj6 The type of a trackable object.
 472  *
 473  * @newin{2,4}
 474  *
 475  * @ingroup track_obj
 476  */
 477 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
 478 class track_obj_functor6 : public track_obj_functor1<T_functor, T_obj1>
 479 {
 480 public:
 481   /** Constructs a track_obj_functor6 object that wraps the passed functor and
 482    * stores references to the passed trackable objects.
 483    * @param _A_func Functor.
 484    * @param _A_obj1 Trackable object.
 485    * @param _A_obj2 Trackable object.
 486    * @param _A_obj3 Trackable object.
 487    * @param _A_obj4 Trackable object.
 488    * @param _A_obj5 Trackable object.
 489    * @param _A_obj6 Trackable object.
 490    */
 491   track_obj_functor6(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6)
 492   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5), obj6_(_A_obj6) {}
 493
 494 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 495 //protected:
 496   // public, so that visit_each() can access it.
 497   const_limit_reference<T_obj2> obj2_;
 498   const_limit_reference<T_obj3> obj3_;
 499   const_limit_reference<T_obj4> obj4_;
 500   const_limit_reference<T_obj5> obj5_;
 501   const_limit_reference<T_obj6> obj6_;
 502 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 503
 504 }; // end class track_obj_functor6
 505
 506 /** track_obj_functor7 wraps a functor and stores 7 references to trackable objects.
 507  * Use the convenience function track_obj() to create an instance of track_obj_functor7.
 508  *
 509  * @tparam T_functor The type of functor to wrap.
 510  * @tparam T_obj1 The type of a trackable object.
 511  * @tparam T_obj2 The type of a trackable object.
 512  * @tparam T_obj3 The type of a trackable object.
 513  * @tparam T_obj4 The type of a trackable object.
 514  * @tparam T_obj5 The type of a trackable object.
 515  * @tparam T_obj6 The type of a trackable object.
 516  * @tparam T_obj7 The type of a trackable object.
 517  *
 518  * @newin{2,4}
 519  *
 520  * @ingroup track_obj
 521  */
 522 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
 523 class track_obj_functor7 : public track_obj_functor1<T_functor, T_obj1>
 524 {
 525 public:
 526   /** Constructs a track_obj_functor7 object that wraps the passed functor and
 527    * stores references to the passed trackable objects.
 528    * @param _A_func Functor.
 529    * @param _A_obj1 Trackable object.
 530    * @param _A_obj2 Trackable object.
 531    * @param _A_obj3 Trackable object.
 532    * @param _A_obj4 Trackable object.
 533    * @param _A_obj5 Trackable object.
 534    * @param _A_obj6 Trackable object.
 535    * @param _A_obj7 Trackable object.
 536    */
 537   track_obj_functor7(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6, const T_obj7& _A_obj7)
 538   : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5), obj6_(_A_obj6), obj7_(_A_obj7) {}
 539
 540 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 541 //protected:
 542   // public, so that visit_each() can access it.
 543   const_limit_reference<T_obj2> obj2_;
 544   const_limit_reference<T_obj3> obj3_;
 545   const_limit_reference<T_obj4> obj4_;
 546   const_limit_reference<T_obj5> obj5_;
 547   const_limit_reference<T_obj6> obj6_;
 548   const_limit_reference<T_obj7> obj7_;
 549 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 550
 551 }; // end class track_obj_functor7
 552
 553
 554 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 555 //template specialization of visitor<>::do_visit_each<>(action, functor):
 556 /** Performs a functor on each of the targets of a functor.
 557  * The function overload for sigc::track_obj_functor1 performs a functor
 558  * on the functor and on the trackable object instances stored in the
 559  * sigc::track_obj_functor1 object.
 560  *
 561  * @newin{2,4}
 562  *
 563  * @ingroup track_obj
 564  */
 565 template <typename T_functor, typename T_obj1>
 566 struct visitor<track_obj_functor1<T_functor, T_obj1> >
 567 {
 568   template <typename T_action>
 569   static void do_visit_each(const T_action& _A_action,
 570                             const track_obj_functor1<T_functor, T_obj1>& _A_target)
 571   {
 572     sigc::visit_each(_A_action, _A_target.functor_);
 573     sigc::visit_each(_A_action, _A_target.obj1_);
 574   }
 575 };
 576
 577 //template specialization of visitor<>::do_visit_each<>(action, functor):
 578 /** Performs a functor on each of the targets of a functor.
 579  * The function overload for sigc::track_obj_functor2 performs a functor
 580  * on the functor and on the trackable object instances stored in the
 581  * sigc::track_obj_functor2 object.
 582  *
 583  * @newin{2,4}
 584  *
 585  * @ingroup track_obj
 586  */
 587 template <typename T_functor, typename T_obj1, typename T_obj2>
 588 struct visitor<track_obj_functor2<T_functor, T_obj1, T_obj2> >
 589 {
 590   template <typename T_action>
 591   static void do_visit_each(const T_action& _A_action,
 592                             const track_obj_functor2<T_functor, T_obj1, T_obj2>& _A_target)
 593   {
 594     sigc::visit_each(_A_action, _A_target.functor_);
 595     sigc::visit_each(_A_action, _A_target.obj1_);
 596     sigc::visit_each(_A_action, _A_target.obj2_);
 597   }
 598 };
 599
 600 //template specialization of visitor<>::do_visit_each<>(action, functor):
 601 /** Performs a functor on each of the targets of a functor.
 602  * The function overload for sigc::track_obj_functor3 performs a functor
 603  * on the functor and on the trackable object instances stored in the
 604  * sigc::track_obj_functor3 object.
 605  *
 606  * @newin{2,4}
 607  *
 608  * @ingroup track_obj
 609  */
 610 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
 611 struct visitor<track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3> >
 612 {
 613   template <typename T_action>
 614   static void do_visit_each(const T_action& _A_action,
 615                             const track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>& _A_target)
 616   {
 617     sigc::visit_each(_A_action, _A_target.functor_);
 618     sigc::visit_each(_A_action, _A_target.obj1_);
 619     sigc::visit_each(_A_action, _A_target.obj2_);
 620     sigc::visit_each(_A_action, _A_target.obj3_);
 621   }
 622 };
 623
 624 //template specialization of visitor<>::do_visit_each<>(action, functor):
 625 /** Performs a functor on each of the targets of a functor.
 626  * The function overload for sigc::track_obj_functor4 performs a functor
 627  * on the functor and on the trackable object instances stored in the
 628  * sigc::track_obj_functor4 object.
 629  *
 630  * @newin{2,4}
 631  *
 632  * @ingroup track_obj
 633  */
 634 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
 635 struct visitor<track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4> >
 636 {
 637   template <typename T_action>
 638   static void do_visit_each(const T_action& _A_action,
 639                             const track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>& _A_target)
 640   {
 641     sigc::visit_each(_A_action, _A_target.functor_);
 642     sigc::visit_each(_A_action, _A_target.obj1_);
 643     sigc::visit_each(_A_action, _A_target.obj2_);
 644     sigc::visit_each(_A_action, _A_target.obj3_);
 645     sigc::visit_each(_A_action, _A_target.obj4_);
 646   }
 647 };
 648
 649 //template specialization of visitor<>::do_visit_each<>(action, functor):
 650 /** Performs a functor on each of the targets of a functor.
 651  * The function overload for sigc::track_obj_functor5 performs a functor
 652  * on the functor and on the trackable object instances stored in the
 653  * sigc::track_obj_functor5 object.
 654  *
 655  * @newin{2,4}
 656  *
 657  * @ingroup track_obj
 658  */
 659 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
 660 struct visitor<track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5> >
 661 {
 662   template <typename T_action>
 663   static void do_visit_each(const T_action& _A_action,
 664                             const track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>& _A_target)
 665   {
 666     sigc::visit_each(_A_action, _A_target.functor_);
 667     sigc::visit_each(_A_action, _A_target.obj1_);
 668     sigc::visit_each(_A_action, _A_target.obj2_);
 669     sigc::visit_each(_A_action, _A_target.obj3_);
 670     sigc::visit_each(_A_action, _A_target.obj4_);
 671     sigc::visit_each(_A_action, _A_target.obj5_);
 672   }
 673 };
 674
 675 //template specialization of visitor<>::do_visit_each<>(action, functor):
 676 /** Performs a functor on each of the targets of a functor.
 677  * The function overload for sigc::track_obj_functor6 performs a functor
 678  * on the functor and on the trackable object instances stored in the
 679  * sigc::track_obj_functor6 object.
 680  *
 681  * @newin{2,4}
 682  *
 683  * @ingroup track_obj
 684  */
 685 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
 686 struct visitor<track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6> >
 687 {
 688   template <typename T_action>
 689   static void do_visit_each(const T_action& _A_action,
 690                             const track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>& _A_target)
 691   {
 692     sigc::visit_each(_A_action, _A_target.functor_);
 693     sigc::visit_each(_A_action, _A_target.obj1_);
 694     sigc::visit_each(_A_action, _A_target.obj2_);
 695     sigc::visit_each(_A_action, _A_target.obj3_);
 696     sigc::visit_each(_A_action, _A_target.obj4_);
 697     sigc::visit_each(_A_action, _A_target.obj5_);
 698     sigc::visit_each(_A_action, _A_target.obj6_);
 699   }
 700 };
 701
 702 //template specialization of visitor<>::do_visit_each<>(action, functor):
 703 /** Performs a functor on each of the targets of a functor.
 704  * The function overload for sigc::track_obj_functor7 performs a functor
 705  * on the functor and on the trackable object instances stored in the
 706  * sigc::track_obj_functor7 object.
 707  *
 708  * @newin{2,4}
 709  *
 710  * @ingroup track_obj
 711  */
 712 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
 713 struct visitor<track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7> >
 714 {
 715   template <typename T_action>
 716   static void do_visit_each(const T_action& _A_action,
 717                             const track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>& _A_target)
 718   {
 719     sigc::visit_each(_A_action, _A_target.functor_);
 720     sigc::visit_each(_A_action, _A_target.obj1_);
 721     sigc::visit_each(_A_action, _A_target.obj2_);
 722     sigc::visit_each(_A_action, _A_target.obj3_);
 723     sigc::visit_each(_A_action, _A_target.obj4_);
 724     sigc::visit_each(_A_action, _A_target.obj5_);
 725     sigc::visit_each(_A_action, _A_target.obj6_);
 726     sigc::visit_each(_A_action, _A_target.obj7_);
 727   }
 728 };
 729
 730 #endif // DOXYGEN_SHOULD_SKIP_THIS
 731
 732 /** Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.
 733  * @param _A_func Functor that shall be wrapped.
 734  * @param _A_obj1 Trackable object.
 735  * @return Adaptor that executes _A_func() on invocation.
 736  *
 737  * @newin{2,4}
 738  *
 739  * @ingroup track_obj
 740  */
 741 template <typename T_functor, typename T_obj1>
 742 inline track_obj_functor1<T_functor, T_obj1>
 743 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1)
 744 {
 745   return track_obj_functor1<T_functor, T_obj1>
 746     (_A_func, _A_obj1);
 747 }
 748
 749 /** Creates an adaptor of type sigc::track_obj_functor2 which wraps a functor.
 750  * @param _A_func Functor that shall be wrapped.
 751  * @param _A_obj1 Trackable object.
 752  * @param _A_obj2 Trackable object.
 753  * @return Adaptor that executes _A_func() on invocation.
 754  *
 755  * @newin{2,4}
 756  *
 757  * @ingroup track_obj
 758  */
 759 template <typename T_functor, typename T_obj1, typename T_obj2>
 760 inline track_obj_functor2<T_functor, T_obj1, T_obj2>
 761 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2)
 762 {
 763   return track_obj_functor2<T_functor, T_obj1, T_obj2>
 764     (_A_func, _A_obj1, _A_obj2);
 765 }
 766
 767 /** Creates an adaptor of type sigc::track_obj_functor3 which wraps a functor.
 768  * @param _A_func Functor that shall be wrapped.
 769  * @param _A_obj1 Trackable object.
 770  * @param _A_obj2 Trackable object.
 771  * @param _A_obj3 Trackable object.
 772  * @return Adaptor that executes _A_func() on invocation.
 773  *
 774  * @newin{2,4}
 775  *
 776  * @ingroup track_obj
 777  */
 778 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
 779 inline track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>
 780 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3)
 781 {
 782   return track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>
 783     (_A_func, _A_obj1, _A_obj2, _A_obj3);
 784 }
 785
 786 /** Creates an adaptor of type sigc::track_obj_functor4 which wraps a functor.
 787  * @param _A_func Functor that shall be wrapped.
 788  * @param _A_obj1 Trackable object.
 789  * @param _A_obj2 Trackable object.
 790  * @param _A_obj3 Trackable object.
 791  * @param _A_obj4 Trackable object.
 792  * @return Adaptor that executes _A_func() on invocation.
 793  *
 794  * @newin{2,4}
 795  *
 796  * @ingroup track_obj
 797  */
 798 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
 799 inline track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>
 800 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4)
 801 {
 802   return track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>
 803     (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4);
 804 }
 805
 806 /** Creates an adaptor of type sigc::track_obj_functor5 which wraps a functor.
 807  * @param _A_func Functor that shall be wrapped.
 808  * @param _A_obj1 Trackable object.
 809  * @param _A_obj2 Trackable object.
 810  * @param _A_obj3 Trackable object.
 811  * @param _A_obj4 Trackable object.
 812  * @param _A_obj5 Trackable object.
 813  * @return Adaptor that executes _A_func() on invocation.
 814  *
 815  * @newin{2,4}
 816  *
 817  * @ingroup track_obj
 818  */
 819 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
 820 inline track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>
 821 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5)
 822 {
 823   return track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>
 824     (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5);
 825 }
 826
 827 /** Creates an adaptor of type sigc::track_obj_functor6 which wraps a functor.
 828  * @param _A_func Functor that shall be wrapped.
 829  * @param _A_obj1 Trackable object.
 830  * @param _A_obj2 Trackable object.
 831  * @param _A_obj3 Trackable object.
 832  * @param _A_obj4 Trackable object.
 833  * @param _A_obj5 Trackable object.
 834  * @param _A_obj6 Trackable object.
 835  * @return Adaptor that executes _A_func() on invocation.
 836  *
 837  * @newin{2,4}
 838  *
 839  * @ingroup track_obj
 840  */
 841 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
 842 inline track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>
 843 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6)
 844 {
 845   return track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>
 846     (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5, _A_obj6);
 847 }
 848
 849 /** Creates an adaptor of type sigc::track_obj_functor7 which wraps a functor.
 850  * @param _A_func Functor that shall be wrapped.
 851  * @param _A_obj1 Trackable object.
 852  * @param _A_obj2 Trackable object.
 853  * @param _A_obj3 Trackable object.
 854  * @param _A_obj4 Trackable object.
 855  * @param _A_obj5 Trackable object.
 856  * @param _A_obj6 Trackable object.
 857  * @param _A_obj7 Trackable object.
 858  * @return Adaptor that executes _A_func() on invocation.
 859  *
 860  * @newin{2,4}
 861  *
 862  * @ingroup track_obj
 863  */
 864 template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
 865 inline track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>
 866 track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6, const T_obj7& _A_obj7)
 867 {
 868   return track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>
 869     (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5, _A_obj6, _A_obj7);
 870 }
 871
 872
 873 } /* namespace sigc */
 874 #endif /* _SIGC_ADAPTORS_TRACK_OBJ_H_ */