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

Namespaces

namespace  dld
namespace  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
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  typed_connection_handler< T_signal, internal::SIGGROUP_SIGC >
class  typed_connection_handler< T_signal, internal::SIGGROUP_GLIB_PROXY >
 Specialization for a Glib::SignalProxyN. More...
class  typed_connection_handler< Glib::SignalIdle, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalIdle. More...
class  typed_connection_handler< Glib::SignalTimeout, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalTimeout. More...
class  typed_connection_handler< Glib::SignalIO, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalIO. More...
class  typed_connection_handler< Glib::SignalChildWatch, internal::SIGGROUP_IRRELEVANT >
 Specialization for a Glib::SignalChildWatch. 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 const types. More...
struct  const_trait< T_type & >
 Specialization for references to non-const types. More...
struct  const_trait< const T_type & >
 Specialization for references to 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...
struct  rw_lockable
 Makes T_type read/write lockable with a Glib::RWLock. More...
class  mutex_lockable
 Makes T_type lockable with a Glib::Mutex. More...
class  static_mutex_lockable
 Makes T_type lockable with a Glib::StaticMutex. More...
class  recmutex_lockable
 Makes T_type lockable with a Glib::RecMutex. More...
class  static_recmutex_lockable
 Makes T_type lockable with a Glib::StaticRecMutex. More...
struct  choose_lock< Glib::RWLock, readlock >
struct  choose_lock< Glib::RWLock, writelock >
struct  choose_lock< Glib::Mutex, I_policy >
struct  choose_lock< Glib::RecMutex, I_policy >
struct  choose_lock< Glib::StaticMutex, I_policy >
struct  choose_lock< Glib::StaticRecMutex, I_policy >
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  writelock_acquirer
class  readlock_acquirer
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...
class  writelock_acquirer< T_type, T_mutex, std::tr1::true_type >
 writelock_acquirer specialization for lockable's. More...
class  readlock_acquirer< T_type, T_mutex, std::tr1::true_type >
 readlock_acquirer specialization for lockable's. More...
struct  lockable_base
 The base for all lockables, template specialized for a specific lock, e.g. a boost::mutex. More...
struct  safe_lockable
 Makes T_type lockable. More...
struct  lockable
 Refinement of safe_lockable, open access to mutex and locked type. More...
class  manual_dispatchable
 A dispatchable whose dispatcher pointer is managed by derived classes. 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  request_f
 Asynchronous request functor for a sigx::threadable. 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< 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< T_signal, internal::SIGGROUP_GLIB_PROXY,-1 >
 A threadsafe wrapper for a Glib::SignalNormalProxy derived signal. More...
class  signal_wrapper< Glib::SignalIdle >
 A threadsafe wrapper for a Glib::SignalIdle. More...
class  signal_wrapper< Glib::SignalTimeout >
 A threadsafe wrapper for a Glib::SignalTimeout. More...
class  signal_wrapper< Glib::SignalIO >
 A threadsafe wrapper for a Glib::SignalIO. More...
class  signal_wrapper< Glib::SignalChildWatch >
 A threadsafe wrapper for a Glib::SignalChildWatch. More...
class  signal_wrapper_base
 The base for a sigx::signal_wrapper. More...
struct  static_assert< true >
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< 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...
class  sync_tunnel_context_base
 Specialities for synchronous tunnel context. More...
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...
struct  volatile_trait
 Traits for adding/removing the volatile qualifier from a type. More...
struct  volatile_trait< volatile T_type >
 Specialization for volatile types. 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...

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.
template<typename T_functor >
 dispatch_with (const T_functor &_A_func, const shared_dispatchable &d)
 Binds a dispatchable explicitly to a functor.
template<typename T_functor >
tunnel_functor< ASYNC, T_functor > open_tunnel (const T_functor &_A_func)
 Opens an asynchronous tunnel on the specified functor.
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.
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.
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.
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)