callback.h File Reference

This file provides classes encapsulating callbacks. More...

#include <functional>
#include <glib.h>
#include <c++-gtk-utils/shared_ptr.h>
#include <c++-gtk-utils/param.h>
#include <c++-gtk-utils/cgu_config.h>

Go to the source code of this file.

Classes
class	Cgu::Callback::CallbackArg
	The callback interface class. More...
class	Cgu::Callback::CallbackArg
	The callback interface class. More...
class	Cgu::Callback::FunctorArg
	Functor class holding a Callback::CallbackArg object. More...
class	Cgu::Callback::SafeFunctorArg
	Functor class holding a Callback::CallbackArg object, with thread-safe reference count. More...
class	Cgu::Callback::FunctorArg
	Functor class holding a Callback::CallbackArg object. More...
class	Cgu::Callback::SafeFunctorArg
	Functor class holding a Callback::CallbackArg object, with thread-safe reference count. More...
class	Cgu::Callback::Callback0< T >
class	Cgu::Callback::CallbackArg0< T, FreeArg >
class	Cgu::Callback::Callback1_< unref, T, BoundArg >
class	Cgu::Callback::CallbackArg1_< unref, T, BoundArg, FreeArg >
class	Cgu::Callback::Callback2_< unref, T, BoundArg1, BoundArg2 >
class	Cgu::Callback::CallbackArg2_< unref, T, BoundArg1, BoundArg2, FreeArg >
class	Cgu::Callback::Callback0_const< T >
class	Cgu::Callback::CallbackArg0_const< T, FreeArg >
class	Cgu::Callback::Callback1_const_< unref, T, BoundArg >
class	Cgu::Callback::CallbackArg1_const_< unref, T, BoundArg, FreeArg >
class	Cgu::Callback::Callback2_const_< unref, T, BoundArg1, BoundArg2 >
class	Cgu::Callback::CallbackArg2_const_< unref, T, BoundArg1, BoundArg2, FreeArg >
class	Cgu::Callback::Callback0_static
class	Cgu::Callback::CallbackArg0_static< FreeArg >
class	Cgu::Callback::Callback1_static_< unref, BoundArg >
class	Cgu::Callback::CallbackArg1_static_< unref, BoundArg, FreeArg >
class	Cgu::Callback::Callback2_static_< unref, BoundArg1, BoundArg2 >
class	Cgu::Callback::CallbackArg2_static_< unref, BoundArg1, BoundArg2, FreeArg >

Namespaces
	Cgu::Callback
	This namespace provides classes encapsulating callbacks.
	Cgu

Typedefs
typedef CallbackArg< void >	Cgu::Callback::Callback
typedef FunctorArg< void >	Cgu::Callback::Functor
typedef SafeFunctorArg< void >	Cgu::Callback::SafeFunctor

Functions
template<class T >
bool	Cgu::Callback::operator== (const FunctorArg< T > &f1, const FunctorArg< T > &f2)
template<class T >
bool	Cgu::Callback::operator!= (const FunctorArg< T > &f1, const FunctorArg< T > &f2)
template<class T >
bool	Cgu::Callback::operator< (const FunctorArg< T > &f1, const FunctorArg< T > &f2)
template<class T >
bool	Cgu::Callback::operator== (const SafeFunctorArg< T > &f1, const SafeFunctorArg< T > &f2)
template<class T >
bool	Cgu::Callback::operator!= (const SafeFunctorArg< T > &f1, const SafeFunctorArg< T > &f2)
template<class T >
bool	Cgu::Callback::operator< (const SafeFunctorArg< T > &f1, const SafeFunctorArg< T > &f2)
template<class T >
Callback *	Cgu::Callback::make (T &t, void(T::*func)())
template<class T >
Callback *	Cgu::Callback::make_val (T &t, void(T::*func)())
template<class T >
Callback *	Cgu::Callback::make_ref (T &t, void(T::*func)())
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (T &t, void(T::*func)(FreeArg))
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (T &t, void(T::*func)(FreeArg))
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (T &t, void(T::*func)(FreeArg))
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (T &t, void(T::*func)(FreeArg1, FreeArg2))
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(FreeArg1, FreeArg2))
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(FreeArg1, FreeArg2))
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3))
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3))
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3))
template<class T , class BoundArg >
Callback *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg), BoundArg arg)
template<class T , class BoundArg >
Callback *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg), const BoundArg &arg)
template<class T , class BoundArg >
Callback *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg), typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg, FreeArg), BoundArg arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg, FreeArg), const BoundArg &arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg, FreeArg), typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2), BoundArg arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2), const BoundArg &arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2), typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), BoundArg arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), const BoundArg &arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg1, BoundArg2), BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg1, BoundArg2), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg1, BoundArg2), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg), BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T >
Callback *	Cgu::Callback::make (const T &t, void(T::*func)() const)
template<class T >
Callback *	Cgu::Callback::make_val (const T &t, void(T::*func)() const)
template<class T >
Callback *	Cgu::Callback::make_ref (const T &t, void(T::*func)() const)
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (const T &t, void(T::*func)(FreeArg) const)
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (const T &t, void(T::*func)(FreeArg) const)
template<class T , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(FreeArg) const)
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (const T &t, void(T::*func)(FreeArg1, FreeArg2) const)
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(FreeArg1, FreeArg2) const)
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(FreeArg1, FreeArg2) const)
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (const T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3) const)
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3) const)
template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(FreeArg1, FreeArg2, FreeArg3) const)
template<class T , class BoundArg >
Callback *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg) const, BoundArg arg)
template<class T , class BoundArg >
Callback *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg) const, const BoundArg &arg)
template<class T , class BoundArg >
Callback *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg) const, typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg, FreeArg) const, BoundArg arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg, FreeArg) const, const BoundArg &arg)
template<class T , class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg, FreeArg) const, typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2) const, BoundArg arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2) const, const BoundArg &arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2) const, typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const, BoundArg arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const, const BoundArg &arg)
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const, typename Cgu::Param< BoundArg >::ParamType arg)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg1, BoundArg2) const, BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg1, BoundArg2) const, const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg1, BoundArg2) const, typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg) const, BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg) const, const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg) const, typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const, BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const, const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const, typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const, BoundArg1 arg1, BoundArg2 arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const, const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (const T &t, void(T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const, typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
Callback *	Cgu::Callback::make (void(*func)())
Callback *	Cgu::Callback::make_val (void(*func)())
Callback *	Cgu::Callback::make_ref (void(*func)())
template<class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (void(*func)(FreeArg))
template<class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (void(*func)(FreeArg))
template<class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (void(*func)(FreeArg))
template<class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (void(*func)(FreeArg1, FreeArg2))
template<class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (void(*func)(FreeArg1, FreeArg2))
template<class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (void(*func)(FreeArg1, FreeArg2))
template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (void(*func)(FreeArg1, FreeArg2, FreeArg3))
template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (void(*func)(FreeArg1, FreeArg2, FreeArg3))
template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (void(*func)(FreeArg1, FreeArg2, FreeArg3))
template<class BoundArg >
Callback *	Cgu::Callback::make (void(*func)(BoundArg), BoundArg arg)
template<class BoundArg >
Callback *	Cgu::Callback::make_val (void(*func)(BoundArg), const BoundArg &arg)
template<class BoundArg >
Callback *	Cgu::Callback::make_ref (void(*func)(BoundArg), typename Cgu::Param< BoundArg >::ParamType arg)
template<class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (void(*func)(BoundArg, FreeArg), BoundArg arg)
template<class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (void(*func)(BoundArg, FreeArg), const BoundArg &arg)
template<class BoundArg , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (void(*func)(BoundArg, FreeArg), typename Cgu::Param< BoundArg >::ParamType arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (void(*func)(BoundArg, FreeArg1, FreeArg2), BoundArg arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (void(*func)(BoundArg, FreeArg1, FreeArg2), const BoundArg &arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (void(*func)(BoundArg, FreeArg1, FreeArg2), typename Cgu::Param< BoundArg >::ParamType arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (void(*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), BoundArg arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (void(*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), const BoundArg &arg)
template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (void(*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3), typename Cgu::Param< BoundArg >::ParamType arg)
template<class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make (void(*func)(BoundArg1, BoundArg2), BoundArg1 arg1, BoundArg2 arg2)
template<class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_val (void(*func)(BoundArg1, BoundArg2), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class BoundArg1 , class BoundArg2 >
Callback *	Cgu::Callback::make_ref (void(*func)(BoundArg1, BoundArg2), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make (void(*func)(BoundArg1, BoundArg2, FreeArg), BoundArg1 arg1, BoundArg2 arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_val (void(*func)(BoundArg1, BoundArg2, FreeArg), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg< FreeArg > *	Cgu::Callback::make_ref (void(*func)(BoundArg1, BoundArg2, FreeArg), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), BoundArg1 arg1, BoundArg2 arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_val (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2 > > *	Cgu::Callback::make_ref (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), BoundArg1 arg1, BoundArg2 arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_val (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), const BoundArg1 &arg1, const BoundArg2 &arg2)
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg< TypeTuple< FreeArg1, FreeArg2, FreeArg3 > > *	Cgu::Callback::make_ref (void(*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3), typename Cgu::Param< BoundArg1 >::ParamType arg1, typename Cgu::Param< BoundArg2 >::ParamType arg2)
void	Cgu::Callback::post (const Callback *cb, gint priority=G_PRIORITY_DEFAULT_IDLE, GMainContext *context=0)
void	Cgu::Callback::post (const Callback *cb, Releaser &r, gint priority=G_PRIORITY_DEFAULT_IDLE, GMainContext *context=0)

Detailed Description

This file provides classes encapsulating callbacks.

#include <c++-gtk-utils/callback.h>

These classes encapsulate callbacks (they are closures). They comprise a generic callback creation and execution interface. There is a basic Callback::Callback type, which is an entire closure or 'thunk', where all the arguments are bound in the constructor and is completely opaque. Callback::CallbackArg<T> is a class which takes one unbound argument of type T when the callback is dispatched, with any other arguments being bound at construction time. (The opaque Callback::Callback type is in fact just a typedef for Callback::CallbackArg<void>: the two types are interchangeable.) In addition, from version 1.2.10 of the library, by default a callback can be executed by a Callback::CallbackArg<T> object with two or three unbound arguments by providing a Cgu::TypeTuple struct as the template type: see under "Usage" below and Constructing callback objects for more than one unbound argument for further information.

The classes can represent static and non-static member functions and plain functions. In the case of a non-static member function, the object whose member function the callback represents must remain in existence until any invocations of the callback have completed. The function referred to must be one of void return type.

The clases are particularly relevant where a callback object may need to be handed between threads, or in other cases where a callback object has to be passed by pointer (which will happen at some stage with glib or pthreads). They are therefore useful for general event passing when used together with the Callback::post() functions, or as the data argument of a call to g_signal_connect_data() in a case where a better design arises when passing arguments known at connect time by storing them in the callback object itself, or as the continuation for GIO async operations.

The classes are also used in the Emitter/EmitterArg classes in emitter.h, which enable callbacks to be connected to an emitter and provide for automatic disconnection where a class object whose member a callback represents ceases to exist.

The Callback::make() functions

The templated helper Callback::make() functions make it trivial to create a callback object of the correct type. A maximum of two bound arguments to pass to the relevant function or class method is provided for and from version 1.2.10 a maximum of three unbound arguments to pass at call time - but this can be extended indefinitely (prior to version 1.2.10 only one unbound argument was provided for). If there are unbound arguments, they must be the last (trailing) arguments of the relevant function or method to be called. Callback/CallbackArg classes do not provide for a return value. If a result is wanted, users should pass an unbound argument by reference or pointer (or pointer to pointer).

Although as mentioned above only two bound and three unbound arguments are provided for, as any of those arguments can be a struct, any number of arguments can be passed as members of a struct (or, in C++11, a std::tuple).

The Callback::make() functions do a direct type mapping from the bound arguments of the function or method represented by the callback object to the arguments stored by the callback object. Bound value arguments of the relevant function or method to be called are therefore stored by value in the callback object. A bound argument can comprise a reference argument (T& or const T&) if the template parameters of the Callback::make() call are qualified by hand to avoid a type mismatch: see under "Usage" below for further particulars, and if the reference argument is non-const this allows the referenced argument to be mutated. However as this would result in the lifetime of the argument not being controlled by the callback object (it would not keep its own copy), it will often be unsafe to do so. (The documentation on Thread::JoinableHandle gives a usage where where binding a reference argument would be safe.)

From version 1.2.13, the library also provides Callback::make_ref() functions, which force the callback object to keep a copy of the value passed where a target function argument is a const reference. It is therefore safe with const reference arguments. No explicit type qualification is required by Callback::make_ref(). In addition the Callback::make_ref() functions provide for more efficient passing of class type bound arguments than does Callback::make(): see further below.

Where more than one unbound argument is to be passed to the target function, the Cgu::TypeTuple type container struct is used - see under Usage below for examples.

The Callback::make_ref() functions

In order to enable the widest variety of types to be accepted as arguments (including mutating non-const reference arguments in those cases where it is safe, and also string literals), as mentioned above when constructing a callback object Callback::make() receives non-reference bound arguments by value, and if unoptimised these may be copied up to two times, and once more when the target function is dispatched. Where a bound argument is a pointer or a fundamental type (an integral or floating-point type), optimization by copy elision will reduce the number of times argument copying takes place when constructing a callback object to once, but the standard does not permit that with class types where the constructor or destructor have side effects or it cannot be ascertained whether they have side effects.

Therefore, to cater for cases where a target function takes a class type argument by const reference or value, from version 1.2.13 the Callback::make_ref() functions are provided. Unlike Callback::make(), when constructing a callback for a target function taking a const reference bound argument, Callback::make_ref() will force the callback object to keep a copy of the argument instead of a reference to that argument. This makes the use of const reference arguments safe (at the cost of the taking of that copy). It cannot be used with non-const references. In addition, Callback::make_ref() automatically passes class type arguments for storage by the callback object by reference to const, so reducing the number of times they are copied, when stored, to once.

In the case of a value argument, at callback dispatch time one additional copy will be made in the normal way when the target function is called, but in the case of a const reference argument no such additional copy will be made. What all this means is that, where bound arguments include a non-trivial class type, the most efficient and exception safe strategy is usually to construct the object of the class type on free store and held by Cgu::SharedPtr or Cgu::SharedLockPtr, have the target function take it by const Cgu::SharedPtr& or const Cgu::SharedLockPtr&, and construct the callback object using Callback::make_ref().

This flexibility of Callback::make_ref() has a downside: unlike Callback::make(), Callback::make_ref() cannot resolve overloaded functions by argument type. Where a function has two or more overloads taking the same number of arguments, explicit disambiguation by the user is required (see further below under Overloaded Functions).

Summary: If a callback object's bound arguments are all simple fundamental types such as pointers (including C strings), integers or floating points, use Callback::make(). Where bound arguments include class types, use Callback::make_ref().

The Callback::make_val() functions

The library also provides Callback::make_val() functions. These are retained to keep code compatibility with earlier versions of the library. They were optimised for use where a target function takes bound arguments of class type by value, but are now deprecated and superseded by the automatic variable type mapping of Callback::make_ref(). Callback::make_ref() should now be used instead of Callback::make_val().

Functors

If a functor class of void return type is required (say for passing to a c++ algorithm or container, or for automatic lifetime management of the Callback object), the Callback::Functor and Callback::FunctorArg wrapper classes can be used. However, for many c++ algorithms where anonymous functors created as temporaries can be used, the std::ptr_fun() and MemFun::make() factory functions will be a more obvious choice.

Callback::SafeFunctor and Callback::SafeFunctorArg classes are the same as Callback::Functor and Callback::FunctorArg classes, except that objects of the safe version may be passed and copied between threads and put in different containers in different threads (that is, the reference count maintained with respect to the contained callback object is thread-safe). They use a SharedLockPtr object to hold the referenced callback object.

Memory allocation

If the library is installed using the --with-glib-memory-slices-compat or --with-glib-memory-slices-no-compat configuration options, any Callback::Functor, Callback::FunctorArg, Callback::SafeFunctor or Callback::SafeFunctorArg objects constructed on free store (usually they won't be) will be constructed in glib memory slices. A contained Callback::Callback or Callback::CallbackArg object, which will always be constructed on free store, will be constructed in glib memory slices if the --with-glib-memory-slices-no-compat configuration option is chosen.

Usage

For a class object my_obj of type MyClass, with a method void MyClass::my_method(int, const char*), usage for a fully bound callback or functor would be:

using namespace Cgu;
int arg = 1;
Callback::Callback* cb =
  Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n");
cb->dispatch();
delete cb;
 
Callback::Functor f(Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n"));
f();

Or for a partially bound callback or functor:

using namespace Cgu;
int arg = 1;
Callback::CallbackArg<const char*>* cb =
  Callback::make(my_obj, &MyClass::my_method, arg);
cb->dispatch("Hello\n");
delete cb;
 
Callback::FunctorArg<const char*> f(Callback::make(my_obj, &MyClass::my_method, arg));
f("Hello\n");

To provide for two or three unbound arguments, from version 1.2.10 of the library the Cgu::TypeTuple struct is used (this struct has no members and is never instantiated, so it does not impose any overhead: see Constructing callback objects for more than one unbound argument for further information). As in the case of a single unbound argument, if there are bound arguments these multiple unbound arguments must be the last (trailing) arguments of the function to be called. For a class object my_obj of type MyClass, with a method void MyClass::my_method2(int, int, int, const char*), usage with two unbound arguments would be:

int arg1 = 1, arg2 = 2, arg3 = 3;
Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, const char*> >* cb =
  Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2);
cb->dispatch(arg3, "Hello\n");
delete cb;
 
Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2));
f(arg3, "Hello\n");

and for three unbound arguments:

int arg1 = 1, arg2 = 2, arg3 = 3;
Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, int, const char*> >* cb =
  Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1);
cb->dispatch(arg2, arg3, "Hello\n");
delete cb;
 
Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1));
f(arg2, arg3, "Hello\n");

The syntax for the construction of a callback object representing a static member function with a signature void MyClass::my_func(int, const char*), or for a normal function, is similar to the non-static member function case, except that the call to Callback::make would comprise:

Callback::make(&MyClass::my_func, arg, "Hello\n");

(fully bound), or

Callback::make(&MyClass::my_func, arg);

(partially bound), and so on.

To bind to reference arguments, the call to Callback::make() must be explicitly typed. For a class object my_obj of type MyClass, with a method void MyClass::my_method(int&), usage for a fully bound callback or functor would be:

int arg = 1;
Callback::Callback* cb =
  Callback::make<MyClass, int&>(my_obj, &MyClass::my_method, arg);

Note however the caveats above about binding to reference arguments.

No similar explicit typing is required by Callback::make_ref(). Thus for a class object my_obj of type MyClass, with a method void MyClass::my_method(int, const Something&), usage for a fully bound callback or functor would be:

int arg1 = 1;
Something arg2;
Callback::Callback* cb =
  Callback::make_ref(my_obj, &MyClass::my_method, arg1, arg2);

Overloaded functions

Note that creating callbacks for overloaded functions can give rise to an ambiguity when using Callback::make(), arising from the fact that the callback object may have an unbound argument. For example:

class MyClass {
  ...
  void add(int i);
  void add(int i, int j);
  void add(double d);
};
MyClass obj;
using namespace Cgu;
Callback::Callback* cb1 = Callback::make(obj, &MyClass::add, 1, 2); // ok
Callback::Callback* cb2 = Callback::make(obj, &MyClass::add, 1.0);  // ok
Callback::Callback* cb3 = Callback::make(obj, &MyClass::add, 1);    // ambiguous - compilation failure

The third call to Callback::make() is ambiguous, as it could be creating a callback for either the function MyClass::add(int) with no unbound argument (that is, creating a Callback::Callback object), or the function MyClass::add(int, int) with an unbound int argument (that is, creating a Callback::CallbackArg<int> object). This situation could be disambiguated by specifically stating the type of the function which is to be chosen, namely, to instantiate the callback in the third call with:

// either:
Callback::Callback* cb3 =
  Callback::make(obj, static_cast<void (MyClass::*)(int)>(&MyClass::add), 1);
// or:
Callback::CallbackArg<int>* cb3 =
  Callback::make(obj, static_cast<void (MyClass::*)(int, int)>(&MyClass::add), 1);

Callback::make_ref() is less capable than Callback::make() at deducing template types. It cannot resolve overloaded functions by examining the arguments passed to it. For example, take a class MyClass as follows:

class MyClass {
  ...
  void add(int i, const double& d);
  void add(const int& j, const int& k);
};

Callback::make_ref() would require explicit disambiguation like this:

Callback::Callback* cb1 =
  Callback::make_ref(obj, static_cast<void (MyClass::*)(int, const double&)>(&MyClass::add), 1, 2.2);
Callback::Callback* cb2 =
  Callback::make_ref(obj, static_cast<void (MyClass::*)(const int&, const int&)>(&MyClass::add), 4, 5);

Posting of callbacks

This file also provides a Callback::post() function which will execute a callback in a glib main loop and can be used (amongst other things) to pass an event from a worker thread to the main program thread. In that respect, it provides an alternative to the Notifier class. It is passed a pointer to a Callback::CallbackArg object created with a call to Callback::make() or Callback::make_ref().

To provide for thread-safe automatic disconnection of the callback if the callback represents a non-static method of an object which may be destroyed before the callback executes in the main loop, include a Releaser as a public member of that object and pass the Releaser object as the second argument of Callback::post(). Note that for this to be race free, the lifetime of the remote object whose method is to be invoked must be determined by the thread to whose main loop the callback has been attached. When the main loop begins invoking the execution of the callback, the remote object must either wholly exist (in which case the callback will be invoked) or have been destroyed (in which case the callback will be ignored), and not be in some transient half-state governed by another thread.

Advantages as against Notifier:

1. If there are a lot of different events requiring callbacks to be dispatched in the program from worker threads to the main thread, this avoids having separate Notifier objects for each event.
2. It is easier to pass arguments with varying values - they can be passed as bound arguments of the callback and no special synchronisation is normally required (the call to g_source_attach() invokes locking of the main loop which will have the effect of ensuring memory visibility). With a Notifier object it may be necessary to use an asynchronous queue to pass variable values (or to bind a reference to the data, thus normally requiring separate synchronisation).
3. Although the callback would normally be sent for execution by the main program loop, and that is the default, it can be sent for execution by any thread which has its own GMainContext/GMainLoop objects. Thus callbacks can be passed for execution between worker threads, or from the main program thread to worker threads, as well as from worker threads to the main program thread.

Disadvantages as against Notifier:

1. Less efficient, as a new callback object has to be created on freestore every time the callback is invoked, together with a new SafeEmitter object if a Releaser is used to track the callback.
2. Multiple callbacks relevant to a single event cannot be invoked from a single call for the event - each callback has to be separately dispatched.