libsigc++ 2.2.10
Public Types | Public Member Functions | Public Attributes
sigc::adapts< T_functor > Struct Template Reference

Base type for adaptors. More...

#include <sigc++/adaptors/adaptor_trait.h>

Inheritance diagram for sigc::adapts< T_functor >:
Inheritance graph
[legend]

List of all members.

Public Types

typedef adaptor_trait
< T_functor >::result_type 
result_type
typedef adaptor_trait
< T_functor >::adaptor_type 
adaptor_type

Public Member Functions

 adapts (const T_functor& _A_functor)
 Constructs an adaptor that wraps the passed functor.

Public Attributes

adaptor_type functor_
 Adaptor that is invoked from operator()().

Detailed Description

template<class T_functor>
struct sigc::adapts< T_functor >

Base type for adaptors.

adapts wraps adaptors, functors, function pointers and class methods. It contains a single member functor which is always a sigc::adaptor_base. The typedef adaptor_type defines the exact type that is used to store the adaptor, functor, function pointer or class method passed into the constructor. It differs from T_functor unless T_functor inherits from sigc::adaptor_base.

Example of a simple adaptor:
 template <class T_functor>
 struct my_adaptor : public sigc::adapts<T_functor>
 {
   template <class T_arg1=void, class T_arg2=void>
   struct deduce_result_type
   { typedef typename sigc::deduce_result_type<T_functor, T_arg1, T_arg2>::type type; };
   typedef typename sigc::functor_trait<T_functor>::result_type result_type;

   result_type
   operator()() const;

   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1) const;

   template <class T_arg1, class T_arg2>
   typename deduce_result_type<T_arg1, T_arg2>::type
   operator()(T_arg1 _A_arg1, class T_arg2) const;

   // Constructs a my_adaptor object that wraps the passed functor.
   // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
   explicit my_adaptor(const T_functor& _A_functor)
     : sigc::adapts<T_functor>(_A_functor) {}
 };

 template <class T_action, class T_functor>
 void visit_each(const T_action& _A_action,
                 const my_adaptor<T_functor>& _A_target)
 {
   visit_each(_A_action, _A_target.functor_);
 }

If you implement your own adaptor, you must also provide your specialization of visit_each<>() that will forward the call to the functor(s) your adapter is wrapping. Otherwise, pointers stored within the functor won't be invalidated when a sigc::trackable object is destroyed and you can end up executing callbacks on destroyed objects.

Your adaptor and your specialization of visit_each<>() must be in the same namespace.


Constructor & Destructor Documentation

template <class T_functor>
sigc::adapts< T_functor >::adapts ( const T_functor &  _A_functor) [inline, explicit]

Constructs an adaptor that wraps the passed functor.

Parameters:
_A_functorFunctor to invoke from operator()().