sigslot::signal_base< Lockable, T > Class Template Reference

#include <sigslot.hpp>

Inheritance diagram for sigslot::signal_base< Lockable, T >:

Public Types
using	arg_list = trait::typelist< T... >
using	ext_arg_list = trait::typelist< connection &, T... >

Public Member Functions
	signal_base () noexcept
	~signal_base () override
	signal_base (const signal_base &)=delete
signal_base &	operator= (const signal_base &)=delete
	signal_base (signal_base &&o)
signal_base &	operator= (signal_base &&o)
template<typename... U>
void	operator() (U &&...a)
template<typename Callable >
std::enable_if_t< trait::is_callable_v< arg_list, Callable >, connection >	connect (Callable &&c, group_id gid=0)
template<typename Callable >
std::enable_if_t< trait::is_callable_v< ext_arg_list, Callable >, connection >	connect_extended (Callable &&c, group_id gid=0)
template<typename Pmf , typename Ptr >
std::enable_if_t< trait::is_callable_v< arg_list, Pmf, Ptr > &&trait::is_observer_v< Ptr >, connection >	connect (Pmf &&pmf, Ptr &&ptr, group_id gid=0)
template<typename Pmf , typename Ptr >
std::enable_if_t< trait::is_callable_v< arg_list, Pmf, Ptr > &&!trait::is_observer_v< Ptr > &&!trait::is_weak_ptr_compatible_v< Ptr >, connection >	connect (Pmf &&pmf, Ptr &&ptr, group_id gid=0)
template<typename Pmf , typename Ptr >
std::enable_if_t< trait::is_callable_v< ext_arg_list, Pmf, Ptr > &&!trait::is_weak_ptr_compatible_v< Ptr >, connection >	connect_extended (Pmf &&pmf, Ptr &&ptr, group_id gid=0)
template<typename Pmf , typename Ptr >
std::enable_if_t<!trait::is_callable_v< arg_list, Pmf > &&trait::is_weak_ptr_compatible_v< Ptr >, connection >	connect (Pmf &&pmf, Ptr &&ptr, group_id gid=0)
template<typename Callable , typename Trackable >
std::enable_if_t< trait::is_callable_v< arg_list, Callable > &&trait::is_weak_ptr_compatible_v< Trackable >, connection >	connect (Callable &&c, Trackable &&ptr, group_id gid=0)
template<typename... CallArgs>
scoped_connection	connect_scoped (CallArgs &&...args)
template<typename Callable >
std::enable_if_t<(trait::is_callable_v< arg_list, Callable >||trait::is_callable_v< ext_arg_list, Callable >||trait::is_pmf_v< Callable >) &&detail::function_traits< Callable >::is_disconnectable, size_t >	disconnect (const Callable &c)
template<typename Obj >
std::enable_if_t<!trait::is_callable_v< arg_list, Obj > &&!trait::is_callable_v< ext_arg_list, Obj > &&!trait::is_pmf_v< Obj >, size_t >	disconnect (const Obj &obj)
template<typename Callable , typename Obj >
size_t	disconnect (const Callable &c, const Obj &obj)
size_t	disconnect (group_id gid)
void	disconnect_all ()
void	block () noexcept
void	unblock () noexcept
bool	blocked () const noexcept
size_t	slot_count () noexcept
Public Member Functions inherited from sigslot::detail::cleanable
virtual	~cleanable ()=default
virtual void	clean (slot_state *)=0

Protected Member Functions
void	clean (detail::slot_state *state) override

Detailed Description

template<typename Lockable, typename... T>
class sigslot::signal_base< Lockable, T >

signal_base is an implementation of the observer pattern, through the use of an emitting object and slots that are connected to the signal and called with supplied arguments when a signal is emitted.

signal_base is the general implementation, whose locking policy must be set in order to decide thread safety guarantees. signal and signal_st are partial specializations for multi-threaded and single-threaded use.

It does not allow slots to return a value.

Slot execution order can be constrained by assigning group ids to the slots. The execution order of slots in a same group is unspecified and should not be relied upon, however groups are executed in ascending group ids order. When the group id of a slot is not set, it is assigned to the group 0. Group ids can have any value in the range of signed 32 bit integers.

Template Parameters

Lockable	a lock type to decide the lock policy
T...	the argument types of the emitting and slots functions.

Member Typedef Documentation

arg_list

template<typename Lockable , typename... T>

using sigslot::signal_base< Lockable, T >::arg_list = trait::typelist<T...>

ext_arg_list

template<typename Lockable , typename... T>

using sigslot::signal_base< Lockable, T >::ext_arg_list = trait::typelist<connection&, T...>

Constructor & Destructor Documentation

signal_base() [1/3]

template<typename Lockable , typename... T>

sigslot::signal_base< Lockable, T >::signal_base ( )

inlinenoexcept

~signal_base()

template<typename Lockable , typename... T>

sigslot::signal_base< Lockable, T >::~signal_base ( )

inlineoverride

signal_base() [2/3]

template<typename Lockable , typename... T>

sigslot::signal_base< Lockable, T >::signal_base ( const signal_base< Lockable, T > &  )

delete

signal_base() [3/3]

template<typename Lockable , typename... T>

sigslot::signal_base< Lockable, T >::signal_base ( signal_base< Lockable, T > &&  o )

inline

Member Function Documentation

block()

template<typename Lockable , typename... T>

void sigslot::signal_base< Lockable, T >::block ( )

inlinenoexcept

Blocks signal emission Safety: thread safe

blocked()

template<typename Lockable , typename... T>

bool sigslot::signal_base< Lockable, T >::blocked ( ) const

inlinenoexcept

Tests blocking state of signal emission

clean()

template<typename Lockable , typename... T>

void sigslot::signal_base< Lockable, T >::clean ( detail::slot_state *  state )

inlineoverrideprotectedvirtual

remove disconnected slots

Implements sigslot::detail::cleanable.

connect() [1/5]

template<typename Lockable , typename... T>

template<typename Callable >

std::enable_if_t< trait::is_callable_v< arg_list, Callable >, connection > sigslot::signal_base< Lockable, T >::connect ( Callable &&  c, group_id  gid = 0  )

inline

Connect a callable of compatible arguments

Effect: Creates and stores a new slot responsible for executing the supplied callable for every subsequent signal emission. Safety: Thread-safety depends on locking policy.

Parameters

c	a callable
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect() [2/5]

template<typename Lockable , typename... T>

template<typename Callable , typename Trackable >

std::enable_if_t< trait::is_callable_v< arg_list, Callable > && trait::is_weak_ptr_compatible_v< Trackable >, connection > sigslot::signal_base< Lockable, T >::connect ( Callable &&  c, Trackable &&  ptr, group_id  gid = 0  )

inline

Overload of connect for lifetime object tracking and automatic disconnection

Trackable must be convertible to an object following a loose form of weak pointer concept, by implementing the ADL-detected conversion function to_weak().

This overload covers the case of a standalone callable and unrelated trackable object.

Note: only weak references are stored, a slot does not extend the lifetime of a suppied object.

Parameters

c	a callable
ptr	a trackable object pointer
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect() [3/5]

template<typename Lockable , typename... T>

template<typename Pmf , typename Ptr >

std::enable_if_t< trait::is_callable_v< arg_list, Pmf, Ptr > && trait::is_observer_v< Ptr >, connection > sigslot::signal_base< Lockable, T >::connect ( Pmf &&  pmf, Ptr &&  ptr, group_id  gid = 0  )

inline

Overload of connect for pointers over member functions derived from observer

Parameters

pmf	a pointer over member function
ptr	an object pointer derived from observer
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect() [4/5]

template<typename Lockable , typename... T>

template<typename Pmf , typename Ptr >

std::enable_if_t< trait::is_callable_v< arg_list, Pmf, Ptr > && !trait::is_observer_v< Ptr > && !trait::is_weak_ptr_compatible_v< Ptr >, connection > sigslot::signal_base< Lockable, T >::connect ( Pmf &&  pmf, Ptr &&  ptr, group_id  gid = 0  )

inline

Overload of connect for pointers over member functions

Parameters

pmf	a pointer over member function
ptr	an object pointer
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect() [5/5]

template<typename Lockable , typename... T>

template<typename Pmf , typename Ptr >

std::enable_if_t<!trait::is_callable_v< arg_list, Pmf > && trait::is_weak_ptr_compatible_v< Ptr >, connection > sigslot::signal_base< Lockable, T >::connect ( Pmf &&  pmf, Ptr &&  ptr, group_id  gid = 0  )

inline

Overload of connect for lifetime object tracking and automatic disconnection

Ptr must be convertible to an object following a loose form of weak pointer concept, by implementing the ADL-detected conversion function to_weak().

This overload covers the case of a pointer over member function and a trackable pointer of that class.

Note: only weak references are stored, a slot does not extend the lifetime of a suppied object.

Parameters

pmf	a pointer over member function
ptr	a trackable object pointer
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect_extended() [1/2]

template<typename Lockable , typename... T>

template<typename Callable >

std::enable_if_t< trait::is_callable_v< ext_arg_list, Callable >, connection > sigslot::signal_base< Lockable, T >::connect_extended ( Callable &&  c, group_id  gid = 0  )

inline

Connect a callable with an additional connection argument

The callable's first argument must be of type connection. This overload the callable to manage it's own connection through this argument.

Parameters

c	a callable
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect_extended() [2/2]

template<typename Lockable , typename... T>

template<typename Pmf , typename Ptr >

std::enable_if_t< trait::is_callable_v< ext_arg_list, Pmf, Ptr > && !trait::is_weak_ptr_compatible_v< Ptr >, connection > sigslot::signal_base< Lockable, T >::connect_extended ( Pmf &&  pmf, Ptr &&  ptr, group_id  gid = 0  )

inline

Overload of connect for pointer over member functions and

Parameters

pmf	a pointer over member function
ptr	an object pointer
gid	an identifier that can be used to order slot execution

Returns

a connection object that can be used to interact with the slot

connect_scoped()

template<typename Lockable , typename... T>

template<typename... CallArgs>

scoped_connection sigslot::signal_base< Lockable, T >::connect_scoped ( CallArgs &&...  args )

inline

Creates a connection whose duration is tied to the return object Use the same semantics as connect

disconnect() [1/4]

template<typename Lockable , typename... T>

template<typename Callable >

std::enable_if_t<(trait::is_callable_v< arg_list, Callable >|| trait::is_callable_v< ext_arg_list, Callable >|| trait::is_pmf_v< Callable >) && detail::function_traits< Callable >::is_disconnectable, size_t > sigslot::signal_base< Lockable, T >::disconnect ( const Callable &  c )

inline

Disconnect slots bound to a callable

Effect: Disconnects all the slots bound to the callable in argument. Safety: Thread-safety depends on locking policy.

If the callable is a free or static member function, this overload is always available. However, RTTI is needed for it to work for pointer to member functions, function objects or and (references to) lambdas, because the C++ spec does not mandate the pointers to member functions to be unique.

Parameters

c	a callable

Returns

the number of disconnected slots

disconnect() [2/4]

template<typename Lockable , typename... T>

template<typename Callable , typename Obj >

size_t sigslot::signal_base< Lockable, T >::disconnect ( const Callable &  c, const Obj &  obj  )

inline

Disconnect slots bound both to a callable and object

Effect: Disconnects all the slots bound to the callable and object in argument. Safety: Thread-safety depends on locking policy.

For naked pointers, the Callable is expected to be a pointer over member function. If obj is trackable, any kind of Callable can be used.

Parameters

c	a callable
obj	an object

Returns

the number of disconnected slots

disconnect() [3/4]

template<typename Lockable , typename... T>

template<typename Obj >

std::enable_if_t<!trait::is_callable_v< arg_list, Obj > && !trait::is_callable_v< ext_arg_list, Obj > && !trait::is_pmf_v< Obj >, size_t > sigslot::signal_base< Lockable, T >::disconnect ( const Obj &  obj )

inline

Disconnect slots bound to this object

Effect: Disconnects all the slots bound to the object or tracked object in argument. Safety: Thread-safety depends on locking policy.

The object may be a pointer or trackable object.

Parameters

obj

an object

Returns

the number of disconnected slots

disconnect() [4/4]

template<typename Lockable , typename... T>

size_t sigslot::signal_base< Lockable, T >::disconnect ( group_id  gid )

inline

Disconnect slots in a particular group

Effect: Disconnects all the slots in the group id in argument. Safety: Thread-safety depends on locking policy.

Parameters

gid	a group id

Returns

the number of disconnected slots

disconnect_all()

template<typename Lockable , typename... T>

void sigslot::signal_base< Lockable, T >::disconnect_all ( )

inline

Disconnects all the slots Safety: Thread safety depends on locking policy

operator()()

template<typename Lockable , typename... T>

template<typename... U>

void sigslot::signal_base< Lockable, T >::operator() ( U &&...  a )

inline

Emit a signal

Effect: All non blocked and connected slot functions will be called with supplied arguments. Safety: With proper locking (see pal::signal), emission can happen from multiple threads simultaneously. The guarantees only apply to the signal object, it does not cover thread safety of potentially shared state used in slot functions.

Parameters

a...	arguments to emit

operator=() [1/2]

template<typename Lockable , typename... T>

signal_base & sigslot::signal_base< Lockable, T >::operator= ( const signal_base< Lockable, T > &  )

delete

operator=() [2/2]

template<typename Lockable , typename... T>

signal_base & sigslot::signal_base< Lockable, T >::operator= ( signal_base< Lockable, T > &&  o )

inline

slot_count()

template<typename Lockable , typename... T>

size_t sigslot::signal_base< Lockable, T >::slot_count ( )

inlinenoexcept

Get number of connected slots Safety: thread safe

unblock()

template<typename Lockable , typename... T>

void sigslot::signal_base< Lockable, T >::unblock ( )

inlinenoexcept

Unblocks signal emission Safety: thread safe

---

The documentation for this class was generated from the following file:

• C:/Users/beiji/Desktop/G&A/oF/of_v0.11.2_vs2017_release/addons/ofxGAKit/libs/gaKit/external/sigslot/sigslot.hpp