sigx++  2.0.1
Namespaces | Data Structures | Typedefs | Enumerations | Functions
sigx Namespace Reference

Namespaces

 dld
 
 internal
 

Data Structures

class  auto_dispatchable
 A dispatchable managing the pointer to the dispatcher. More...
 
class  bad_caller
 
class  bad_dispatcher
 
struct  bad_dispatcher_catcher
 Catcher for a sigc::exception_catch_functor ignoring exceptions of type sigx::bad_dispatcher. More...
 
class  bad_sync_call
 
struct  choose_lock
 Metafunction that chooses an appropriate scoped lock for a mutex. More...
 
struct  choose_lock< Glib::Mutex, I_policy >
 
struct  choose_lock< Glib::RecMutex, I_policy >
 
struct  choose_lock< Glib::RWLock, readlock >
 
struct  choose_lock< Glib::RWLock, writelock >
 
struct  choose_lock< Glib::StaticMutex, I_policy >
 
struct  choose_lock< Glib::StaticRecMutex, I_policy >
 
class  connection_handler
 Stores connections of any client thread to a server thread's signal and destroys them along with the thread's lifetime. More...
 
class  connection_wrapper
 A threadsafe representation of a sigc::connection. More...
 
struct  const_trait
 Traits for adding/removing the const qualifier from a type. More...
 
struct  const_trait< const T_type & >
 Specialization for references to const types. More...
 
struct  const_trait< const T_type >
 Specialization for const types. More...
 
struct  const_trait< T_type & >
 Specialization for references to non-const types. More...
 
class  dispatchable
 Derived classes designate their ability to dispatch messages over a sigx::dispatcher. More...
 
class  dispatcher
 base class denoting the ability to dispatch messages between threads. More...
 
class  glib_auto_dispatchable
 
class  glib_dispatcher
 a dispatcher on top of Glib::dispatcher. More...
 
class  glib_threadable
 A useful and convenient thread wrapper for Glib threads. More...
 
class  lock_acquirer
 Locks the given mutex and ensures threadsafe write access to the given locked type. More...
 
class  lock_acquirer< I_policy, T_type, T_mutex, std::tr1::true_type >
 Specialization for a lockable_base derived object; locks the given lockable object (e.g. a mutex_lockable) and ensures threadsafe write access to the locked type. More...
 
struct  lockable
 Refinement of safe_lockable, open access to mutex and locked type. More...
 
struct  lockable_base
 The base for all lockables, template specialized for a specific lock, e.g. a boost::mutex. More...
 
class  manual_dispatchable
 A dispatchable whose dispatcher pointer is managed by derived classes. More...
 
class  mutex_lockable
 Makes T_type lockable with a Glib::Mutex. More...
 
class  nonassignable
 Private assignment operator (operator =) ensures that derived classes can't be copied by assignment. More...
 
class  noncopyable
 Private copy constructor and copy assignment ensure derived classes cannot be copied. More...
 
class  nonheapallocatable
 Private operator new and delete ensure derived classes cannot be created with new on the heap. More...
 
class  noninstantiatable
 A Private constructor ensures derived classes cannot be created. More...
 
class  nonpointeraliasing
 Private address operator (operator &) ensures that the address of derived objects can't be taken. More...
 
class  operator_new
 Ensures allocation of derived objects in the sigx module. More...
 
class  readlock_acquirer
 
class  readlock_acquirer< T_type, T_mutex, std::tr1::true_type >
 readlock_acquirer specialization for lockable's. More...
 
class  recmutex_lockable
 Makes T_type lockable with a Glib::RecMutex. More...
 
class  request_f
 Asynchronous request functor for a sigx::threadable. More...
 
struct  rw_lockable
 Makes T_type read/write lockable with a Glib::RWLock. More...
 
struct  safe_lockable
 Makes T_type lockable. More...
 
class  shared_dispatchable
 thread safe dispatcher reference that can be passed around. More...
 
class  signal_f
 Functor returning a sigx::signal_wrapper as a threadsafe signal wrapper. More...
 
class  signal_f_base
 Base class for signal functors, see signal_f. More...
 
class  signal_source_base
 Represents a source for any type of signal. More...
 
struct  signal_source_func
 signal source is a signal of type T_signal returned by a functor. More...
 
struct  signal_source_obj_mem
 signal source is a object's member of type T_signal. More...
 
struct  signal_source_pobj_mem
 signal source is a object's member of type T_signal. Object instance is late bound. More...
 
struct  signal_source_pobj_mem_fun
 signal source is a object's member function returning a signal of type T_signal. Object instance is late bound. More...
 
struct  signal_source_threadprivate
 signal source is a signal of type T_signal from a thread private data object's member. More...
 
class  signal_wrapper
 A threadsafe wrapper for sigc signals, Glib signals or theoretically any other type of signal. More...
 
class  signal_wrapper< Glib::SignalChildWatch >
 A threadsafe wrapper for a Glib::SignalChildWatch. More...
 
class  signal_wrapper< Glib::SignalIdle >
 A threadsafe wrapper for a Glib::SignalIdle. More...
 
class  signal_wrapper< Glib::SignalIO >
 A threadsafe wrapper for a Glib::SignalIO. More...
 
class  signal_wrapper< Glib::SignalTimeout >
 A threadsafe wrapper for a Glib::SignalTimeout. More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_GLIB_PROXY,-1 >
 A threadsafe wrapper for a Glib::SignalNormalProxy derived signal. More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 0 >
 A threadsafe wrapper for any sigc signal with 0 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 1 >
 A threadsafe wrapper for any sigc signal with 1 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 2 >
 A threadsafe wrapper for any sigc signal with 2 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 3 >
 A threadsafe wrapper for any sigc signal with 3 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 4 >
 A threadsafe wrapper for any sigc signal with 4 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 5 >
 A threadsafe wrapper for any sigc signal with 5 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 6 >
 A threadsafe wrapper for any sigc signal with 6 argument(s). More...
 
class  signal_wrapper< T_signal, internal::SIGGROUP_SIGC, 7 >
 A threadsafe wrapper for any sigc signal with 7 argument(s). More...
 
class  signal_wrapper_base
 The base for a sigx::signal_wrapper. More...
 
struct  static_assert
 
struct  static_assert< true >
 
class  static_mutex_lockable
 Makes T_type lockable with a Glib::StaticMutex. More...
 
class  static_recmutex_lockable
 Makes T_type lockable with a Glib::StaticRecMutex. More...
 
class  sync_tunnel_context_base
 Specialities for synchronous tunnel context. More...
 
class  threadable
 Derived classes denote that they are a thread wrapper. More...
 
class  tunnel_base
 A hint to the compiler that the functor is a tunnel_functor. More...
 
struct  tunnel_context
 Represents a tunnel message. More...
 
struct  tunnel_context< ASYNC, T_return, T_unary_functor >
 An asynchronous tunnel message. More...
 
struct  tunnel_context< SYNC, T_return, T_unary_functor >
 A synchronous tunnel message. More...
 
struct  tunnel_context< SYNC, void, T_unary_functor >
 a synchronous tunnel with return type `void". More...
 
class  tunnel_context_base
 the base class for all tunnel_context classes. More...
 
struct  tunnel_functor
 
struct  tunnel_functor< ASYNC, T_functor >
 creates a tunnel on the given functor. More...
 
struct  tunnel_functor< SYNC, T_functor >
 
class  tunnel_validity_tracker
 Interface for tracking the validity of a tunnel. More...
 
class  typed_connection_handler
 
class  typed_connection_handler< Glib::SignalChildWatch, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalChildWatch. More...
 
class  typed_connection_handler< Glib::SignalIdle, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalIdle. More...
 
class  typed_connection_handler< Glib::SignalIO, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalIO. More...
 
class  typed_connection_handler< Glib::SignalTimeout, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalTimeout. More...
 
class  typed_connection_handler< T_signal, internal::SIGGROUP_GLIB_PROXY >
 Specialization for a Glib::SignalProxyN. More...
 
class  typed_connection_handler< T_signal, internal::SIGGROUP_SIGC >
 
struct  volatile_trait
 Traits for adding/removing the volatile qualifier from a type. More...
 
struct  volatile_trait< T_type & >
 Specialization for references to non-volatile types. More...
 
struct  volatile_trait< volatile T_type & >
 Specialization for references to volatile types. More...
 
struct  volatile_trait< volatile T_type >
 Specialization for volatile types. More...
 
class  writelock_acquirer
 
class  writelock_acquirer< T_type, T_mutex, std::tr1::true_type >
 writelock_acquirer specialization for lockable's. More...
 

Typedefs

typedef const void * threadhandle_type
 
typedef dispatcherdispatcher_ptr
 
typedef signal_source_basesignal_source_ptr
 
typedef sigc::connection * sigc_connection_ptr
 
typedef signal_wrapper< Glib::SignalIdle > glib_signal_idle
 
typedef signal_wrapper< Glib::SignalTimeout > glib_signal_timeout
 
typedef signal_wrapper< Glib::SignalIO > glib_signal_io
 
typedef signal_wrapper< Glib::SignalChildWatch > glib_ignal_childwatch
 

Enumerations

enum  locking_policy { readlock, writelock }
 
enum  sync_type { ASYNC, SYNC }
 specifies the synchronization mode of the tunnel, i.e. whether the message should be sent asynchronous or synchronous More...
 

Functions

template<class T_type >
sigc::reference_wrapper< T_type > ref (T_type &v)
 
template<class T_type >
sigc::const_reference_wrapper< T_type > ref (const T_type &v)
 
template<class T_type >
sigc::reference_wrapper< T_type > ref (const sigc::reference_wrapper< T_type > &v)
 
template<class T_type >
sigc::const_reference_wrapper< T_type > ref (const sigc::const_reference_wrapper< T_type > &v)
 
template<sync_type I_sync, typename T_return , typename T_adaptor >
tunnel_context< I_sync, T_return, T_adaptor > * make_new_tunnel_context (const shared_dispatchable &_A_disp, const tunnel_validity_tracker &_A_validity_tracker, const T_adaptor &_A_func)
 Exists solely to make the compiler deduce the meta argument T_adaptor. More...
 
template<typename T_functor >
 dispatch_with (const T_functor &_A_func, const shared_dispatchable &d)
 Binds a dispatchable explicitly to a functor. More...
 
template<typename T_functor >
tunnel_functor< ASYNC, T_functor > open_tunnel (const T_functor &_A_func)
 Opens an asynchronous tunnel on the specified functor. More...
 
template<typename T_functor >
tunnel_functor< SYNC, T_functor > open_sync_tunnel (const T_functor &_A_func)
 Opens a synchronous tunnel on the specified functor. More...
 
template<typename T_functor >
tunnel_functor< ASYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)> open_tunnel_with (const T_functor &_A_func, const shared_dispatchable &d)
 Opens an asynchronous tunnel on the specified functor with the dispatcher of the specified dispatchable. More...
 
template<typename T_functor >
tunnel_functor< SYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)> open_sync_tunnel_with (const T_functor &_A_func, const shared_dispatchable &d)
 Opens a synchronous tunnel on the specified functor with the dispatcher of the specified dispatchable. More...
 
template<typename T , typename T_src >
volatile_cast (T_src &tsrc)
 
void *operator_new::operator new (std::size_t size)
 
void operator_new::operator delete (void *p)
 

Typedef Documentation

typedef signal_wrapper<Glib::SignalChildWatch> sigx::glib_ignal_childwatch
typedef signal_wrapper<Glib::SignalIdle> sigx::glib_signal_idle
typedef signal_wrapper<Glib::SignalIO> sigx::glib_signal_io
typedef signal_wrapper<Glib::SignalTimeout> sigx::glib_signal_timeout
typedef sigc::connection* sigx::sigc_connection_ptr
typedef const void* sigx::threadhandle_type

Enumeration Type Documentation

Enumerator
readlock 
writelock 

specifies the synchronization mode of the tunnel, i.e. whether the message should be sent asynchronous or synchronous

Note
asynchronous tunnels are the default
open_tunnel<ASYNC>(&callback)();
// is the same as:
open_tunnel(&callback)();
other types are thinkable like a SYNC_TIMED
Enumerator
ASYNC 
SYNC 

Function Documentation

void operator_new::operator sigx::delete ( void *  p)
template<sync_type I_sync, typename T_return , typename T_adaptor >
tunnel_context<I_sync, T_return, T_adaptor>* sigx::make_new_tunnel_context ( const shared_dispatchable _A_disp,
const tunnel_validity_tracker _A_validity_tracker,
const T_adaptor &  _A_func 
)

Exists solely to make the compiler deduce the meta argument T_adaptor.

void* operator_new::operator sigx::new ( std::size_t  size)
template<class T_type >
sigc::reference_wrapper<T_type> sigx::ref ( T_type &  v)
template<class T_type >
sigc::const_reference_wrapper<T_type> sigx::ref ( const T_type &  v)
template<class T_type >
sigc::reference_wrapper<T_type> sigx::ref ( const sigc::reference_wrapper< T_type > &  v)
template<class T_type >
sigc::const_reference_wrapper<T_type> sigx::ref ( const sigc::const_reference_wrapper< T_type > &  v)