c++-gtk-utils
Classes | Typedefs | Functions
Cgu::Callback Namespace Reference

This namespace provides classes encapsulating callbacks. More...

Classes

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

Typedefs

typedef CallbackArg< void > Callback
 
typedef FunctorArg< void > Functor
 
typedef SafeFunctorArg< void > SafeFunctor
 

Functions

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

Detailed Description

This namespace 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::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::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::make(my_obj, &MyClass::my_method2, arg1, arg2);
cb->dispatch(arg3, "Hello\n");
delete cb;
f(arg3, "Hello\n");

and for three unbound arguments:

int arg1 = 1, arg2 = 2, arg3 = 3;
Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1);
cb->dispatch(arg2, arg3, "Hello\n");
delete cb;
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::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::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::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::make_ref(obj, static_cast<void (MyClass::*)(int, const double&)>(&MyClass::add), 1, 2.2);
Callback::make_ref(obj, static_cast<void (MyClass::*)(const int&, const int&)>(&MyClass::add), 4, 5);

Posting of callbacks

This namespace 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.

Typedef Documentation

Function Documentation

template<class T >
Callback* Cgu::Callback::make ( T &  t,
void(T::*)()  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( T &  t,
void(T::*)(FreeArg)  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( T &  t,
void(T::*)(FreeArg1, FreeArg2)  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3)  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg >
Callback* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg, FreeArg)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg1, BoundArg2)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T >
Callback* Cgu::Callback::make ( const T &  t,
void(T::*)() const  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( const T &  t,
void(T::*)(FreeArg) const  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( const T &  t,
void(T::*)(FreeArg1, FreeArg2) const  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( const T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3) const  func 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg >
Callback* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg) const  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg, FreeArg) const  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2) const  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg1, BoundArg2) const  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg) const  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

Callback* Cgu::Callback::make ( void(*)()  func)
inline

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( void(*)(FreeArg)  func)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).
template<class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( void(*)(FreeArg1, FreeArg2)  func)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( void(*)(FreeArg1, FreeArg2, FreeArg3)  func)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg >
Callback* Cgu::Callback::make ( void(*)(BoundArg)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( void(*)(BoundArg, FreeArg)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( void(*)(BoundArg, FreeArg1, FreeArg2)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( void(*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
BoundArg  arg 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make ( void(*)(BoundArg1, BoundArg2)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make ( void(*)(BoundArg1, BoundArg2, FreeArg)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.
template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
BoundArg1  arg1,
BoundArg2  arg2 
)

A convenience function to make Callback::CallbackArg objects

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T >
Callback* Cgu::Callback::make_ref ( T &  t,
void(T::*)()  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( T &  t,
void(T::*)(FreeArg)  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( T &  t,
void(T::*)(FreeArg1, FreeArg2)  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3)  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class BoundArg >
Callback* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg, FreeArg)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg1, BoundArg2)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T >
Callback* Cgu::Callback::make_ref ( const T &  t,
void(T::*)() const  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(FreeArg) const  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(FreeArg1, FreeArg2) const  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3) const  func 
)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class T , class BoundArg >
Callback* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg) const  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg, FreeArg) const  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2) const  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

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::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg1, BoundArg2) const  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg) const  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

Callback* Cgu::Callback::make_ref ( void(*)()  func)
inline

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( void(*)(FreeArg)  func)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( void(*)(FreeArg1, FreeArg2)  func)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( void(*)(FreeArg1, FreeArg2, FreeArg3)  func)

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.13

template<class BoundArg >
Callback* Cgu::Callback::make_ref ( void(*)(BoundArg)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( void(*)(BoundArg, FreeArg)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( void(*)(BoundArg, FreeArg1, FreeArg2)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( void(*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
typename Cgu::Param< BoundArg >::ParamType  arg 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_ref ( void(*)(BoundArg1, BoundArg2)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_ref ( void(*)(BoundArg1, BoundArg2, FreeArg)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_ref ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_ref ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
typename Cgu::Param< BoundArg1 >::ParamType  arg1,
typename Cgu::Param< BoundArg2 >::ParamType  arg2 
)

An alternative function to make Callback::CallbackArg objects, which is for use where a target function either receives a class type bound argument by value, or receives a bound argument by reference to const in a case where the generated CallbackArg object is to store a copy of that argument instead of just keeping a reference.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws.

Since 1.2.13

template<class T >
Callback* Cgu::Callback::make_val ( T &  t,
void(T::*)()  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( T &  t,
void(T::*)(FreeArg)  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( T &  t,
void(T::*)(FreeArg1, FreeArg2)  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3)  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg >
Callback* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg, FreeArg)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg1, BoundArg2)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T >
Callback* Cgu::Callback::make_val ( const T &  t,
void(T::*)() const  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class T , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( const T &  t,
void(T::*)(FreeArg) const  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class T , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( const T &  t,
void(T::*)(FreeArg1, FreeArg2) const  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( const T &  t,
void(T::*)(FreeArg1, FreeArg2, FreeArg3) const  func 
)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class T , class BoundArg >
Callback* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg) const  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg, FreeArg) const  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg, FreeArg1, FreeArg2) const  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

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::*)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T , class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg1, BoundArg2) const  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg) const  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class T , class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( const T &  t,
void(T::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

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::*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

Callback* Cgu::Callback::make_val ( void(*)()  func)
inline

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( void(*)(FreeArg)  func)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.8

template<class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( void(*)(FreeArg1, FreeArg2)  func)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( void(*)(FreeArg1, FreeArg2, FreeArg3)  func)

DEPRECATED.

Since this function constructs a callback which does not take a bound argument, it is a synonym for make() (the two are identical).

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg >
Callback* Cgu::Callback::make_val ( void(*)(BoundArg)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class BoundArg , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( void(*)(BoundArg, FreeArg)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class BoundArg , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( void(*)(BoundArg, FreeArg1, FreeArg2)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( void(*)(BoundArg, FreeArg1, FreeArg2, FreeArg3)  func,
const BoundArg &  arg 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg1 , class BoundArg2 >
Callback* Cgu::Callback::make_val ( void(*)(BoundArg1, BoundArg2)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class BoundArg1 , class BoundArg2 , class FreeArg >
CallbackArg<FreeArg>* Cgu::Callback::make_val ( void(*)(BoundArg1, BoundArg2, FreeArg)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.8

template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* Cgu::Callback::make_val ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case. This exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option (instead glib will terminate the program if it is unable to obtain memory from the operating system).

Since 1.2.10

template<class BoundArg1 , class BoundArg2 , class FreeArg1 , class FreeArg2 , class FreeArg3 >
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* Cgu::Callback::make_val ( void(*)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3)  func,
const BoundArg1 &  arg1,
const BoundArg2 &  arg2 
)

DEPRECATED: use Callback::make_ref() instead.

An alternative function to make Callback::CallbackArg objects, which is for use where a target function receives an argument of class type by value which is to be a bound argument, so the compiler is not able to carry out copy elision when constructing the callback object.

Exceptions
std::bad_allocIt might throw std::bad_alloc if memory is exhausted and the system throws in that case (this exception will not be thrown if the library has been installed using the --with-glib-memory-slices-no-compat configuration option: instead glib will terminate the program if it is unable to obtain memory from the operating system). It will also throw if the copy constructor of a bound argument throws and it is not a reference argument.

Since 1.2.10

template<class T >
bool Cgu::Callback::operator!= ( const FunctorArg< T > &  f1,
const FunctorArg< T > &  f2 
)

Two FunctorArg objects compare unequal if the addresses of the CallbackArg objects they contain are not the same. This comparison operator does not throw.

Since 1.2.5

template<class T >
bool Cgu::Callback::operator!= ( const SafeFunctorArg< T > &  f1,
const SafeFunctorArg< T > &  f2 
)

Two SafeFunctorArg objects compare unequal if the addresses of the CallbackArg objects they contain are not the same. This comparison operator does not throw.

Since 1.2.5

template<class T >
bool Cgu::Callback::operator< ( const FunctorArg< T > &  f1,
const FunctorArg< T > &  f2 
)

One FunctorArg object is less than another if the address of the CallbackArg object contained by the first is regarded by std::less as less than the address of the CallbackArg object contained by the other. This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation).

template<class T >
bool Cgu::Callback::operator< ( const SafeFunctorArg< T > &  f1,
const SafeFunctorArg< T > &  f2 
)

One SafeFunctorArg object is less than another if the address of the CallbackArg object contained by the first is regarded by std::less as less than the address of the CallbackArg object contained by the other. This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation).

template<class T >
bool Cgu::Callback::operator== ( const FunctorArg< T > &  f1,
const FunctorArg< T > &  f2 
)

Two FunctorArg objects compare equal if the addresses of the CallbackArg objects they contain are the same. This comparison operator does not throw.

template<class T >
bool Cgu::Callback::operator== ( const SafeFunctorArg< T > &  f1,
const SafeFunctorArg< T > &  f2 
)

Two SafeFunctorArg objects compare equal if the addresses of the CallbackArg objects they contain are not the same. This comparison operator does not throw.

void Cgu::Callback::post ( const Callback cb,
gint  priority = G_PRIORITY_DEFAULT_IDLE,
GMainContext *  context = 0 
)

Posts a callback for execution by a glib main loop. It is thread-safe provided that (if glib < 2.32 is used) g_thread_init() has been called. glib >= 2.32 does not require g_thread_init() to be called. This function will not throw.

Parameters
cbThe callback object. Ownership is taken of this object, and it will be deleted when it has been finished with.
priorityThe priority to be given to the callback in the main loop. In ascending order of priorities, priorities are G_PRIORITY_LOW, G_PRIORITY_DEFAULT_IDLE, G_PRIORITY_HIGH_IDLE, G_PRIORITY_DEFAULT and G_PRIORITY_HIGH. The default is G_PRIORITY_DEFAULT_IDLE. This determines the order in which the callback will appear in the event list in the main loop, not the priority which the OS will adopt
contextThe glib main loop context in which the callback is to be executed (the default of NULL will cause the callback to be executed in the main program loop, and this is usually what is wanted).
Note
1. Cancellation of the receiving thread is blocked when the callback executes.
2. If the callback throws an exception, the exception will be consumed to protect the main loop and a g_critical() warning will be issued.

Since 0.9.2 choice of main context available.

void Cgu::Callback::post ( const Callback cb,
Releaser r,
gint  priority = G_PRIORITY_DEFAULT_IDLE,
GMainContext *  context = 0 
)

Posts a callback for execution by a glib main loop. It is thread-safe provided that (if glib < 2.32 is used) g_thread_init() has been called. glib >= 2.32 does not require g_thread_init() to be called. This function will not throw.

Parameters
cbThe callback object. Ownership is taken of this object, and it will be deleted when it has been finished with.
rA Releaser object for automatic disconnection of the callback before it executes in the main loop (mainly relevant if the callback represents a non-static member function of an object which may be destroyed before the callback executes).
priorityThe priority to be given to the callback in the main loop. In ascending order of priorities, priorities are G_PRIORITY_LOW, G_PRIORITY_DEFAULT_IDLE, G_PRIORITY_HIGH_IDLE, G_PRIORITY_DEFAULT and G_PRIORITY_HIGH. The default is G_PRIORITY_DEFAULT_IDLE. This determines the order in which the callback will appear in the event list in the main loop, not the priority which the OS will adopt.
contextThe glib main loop context in which the callback is to be executed (the default of NULL will cause the callback to be executed in the main program loop, and this is usually what is wanted).
Exceptions
std::bad_allocThis function might throw std::bad_alloc if memory is exhausted and the system throws in that case. If it does so, the Callback object will be disposed of.
Cgu::Thread::MutexErrorThis function might throw Cgu:Thread::MutexError if initialisation of the mutex in a SafeEmitterArg object constructed by this function fails. If it does so, the Callback object will be disposed of. (It is often not worth checking for this exception, as it means either memory is exhausted or pthread has run out of other resources to create new mutexes.)
Note
1. Cancellation of the receiving thread is blocked when the callback executes.
2. If the callback throws an exception, the exception will be consumed to protect the main loop and a g_critical() warning will be issued.
3. By virtue of the Releaser object, it is in theory possible (if memory is exhausted and the system throws in that case) that an internal SafeEmitterArg object will throw std::bad_alloc when emitting/executing the callback in the glib main loop, with the result that the relevant callback will not execute (instead the exception will be consumed and a g_critical() warning will be issued). This is rarely of any relevance because glib will abort the program if it is itself unable to obtain memory from the operating system. However, where it is relevant, design the program so that it is not necessary to provide a releaser object.

Since 0.9.2 choice of main context available.