libs/sigc++2/sigc++/visit_each.h

   1 // -*- c++ -*-
   2 /*
   3  * Copyright 2002, The libsigc++ Development Team
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Lesser General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2.1 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  *  Lesser General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Lesser General Public
  16  *  License along with this library; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  */
  20 #ifndef _SIGC_VISIT_EACH_HPP_
  21 #define _SIGC_VISIT_EACH_HPP_
  22
  23 #include <sigc++/type_traits.h>
  24
  25 namespace sigc {
  26
  27 namespace internal {
  28
  29 /// Helper struct for visit_each_type().
  30 template <class T_target, class T_action>
  31 struct limit_derived_target
  32 {
  33   typedef limit_derived_target<T_target, T_action> T_self;
  34
  35   template <bool I_derived, class T_type> struct with_type;
  36
  37   template <class T_type> struct with_type<false,T_type>
  38   { static void execute_(const T_type&, const T_self&) {} };
  39
  40   template <class T_type> struct with_type<true,T_type>
  41   { static void execute_(const T_type& _A_type, const T_self& _A_action)
  42       { _A_action.action_(_A_type); }
  43   };
  44
  45   template <class T_type>
  46   void operator()(const T_type& _A_type) const
  47   { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
  48
  49   limit_derived_target(const T_action& _A_action): action_(_A_action) {}
  50
  51   T_action action_;
  52 };
  53
  54 /// Helper struct for visit_each_type().
  55 template <class T_target, class T_action>
  56 struct limit_derived_target<T_target*, T_action>
  57 {
  58   typedef limit_derived_target<T_target*, T_action> T_self;
  59
  60   template <bool I_derived, class T_type> struct with_type;
  61
  62   template <class T_type> struct with_type<false,T_type>
  63   { static void execute_(const T_type&, const T_self&) {} };
  64
  65   template <class T_type> struct with_type<true,T_type>
  66   { static void execute_(const T_type& _A_type, const T_self& _A_action)
  67      { _A_action.action_(&_A_type); }
  68   };
  69
  70   template <class T_type>
  71   void operator()(const T_type& _A_type) const
  72   { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
  73
  74   limit_derived_target(const T_action& _A_action): action_(_A_action) {}
  75
  76   T_action action_;
  77 };
  78
  79 } /* namespace internal */
  80
  81
  82 /** This function performs a functor on each of the targets of a functor.
  83  * All unknown types just call @e _A_action on them.
  84  * Add overloads that specialize the @e T_functor argument for your own
  85  * functor types, so that subobjects get visited. This is needed to enable
  86  * auto-disconnection support for your functor types.
  87  *
  88  * @par Example:
  89  *   @code
  90  *   struct some_functor
  91  *   {
  92  *     void operator()() {}
  93  *     some_possibly_sigc_trackable_derived_type some_data_member;
  94  *     some_other_functor_type some_other_functor;
  95  *   }
  96  *
  97  *   namespace sigc
  98  *   {
  99  *     template <class T_action>
 100  *     void visit_each(const T_action& _A_action,
 101  *                     const some_functor& _A_target)
 102  *     {
 103  *       visit_each(_A_action, _A_target.some_data_member);
 104  *       visit_each(_A_action, _A_target.some_other_functor);
 105  *     }
 106  *   }
 107  *   @endcode
 108  *
 109  * @ingroup functors
 110  */
 111 template <class T_action, class T_functor>
 112 void visit_each(const T_action& _A_action, const T_functor& _A_functor)
 113 { _A_action(_A_functor); }
 114
 115 /** This function performs a functor on each of the targets
 116  * of a functor limited to a restricted type.
 117  *
 118  * @ingroup functors
 119  */
 120 template <class T_type, class T_action, class T_functor>
 121 void visit_each_type(const T_action& _A_action, const T_functor& _A_functor)
 122 {
 123   internal::limit_derived_target<T_type,T_action> limited_action(_A_action);
 124   visit_each(limited_action,_A_functor);
 125 }
 126
 127 } /* namespace sigc */
 128 #endif