From d0ffa8615d9f0aa5d5e3d17e5cab6ebdddc21846 Mon Sep 17 00:00:00 2001 From: deadbeef Date: Fri, 12 May 2017 22:52:51 -0700 Subject: [PATCH] Run clang-format on sigslot.h. It's diverged enough from the original version that we no longer benefit from keeping the old formatting. BUG=NONE Review-Url: https://codereview.webrtc.org/2854533002 Cr-Commit-Position: refs/heads/master@{#18129} --- webrtc/base/sigslot.h | 1053 ++++++++++++++++++++--------------------- 1 file changed, 507 insertions(+), 546 deletions(-) diff --git a/webrtc/base/sigslot.h b/webrtc/base/sigslot.h index c0fe5050fe..4649f51613 100644 --- a/webrtc/base/sigslot.h +++ b/webrtc/base/sigslot.h @@ -2,79 +2,88 @@ // // Written by Sarah Thompson (sarah@telergy.com) 2002. // -// License: Public domain. You are free to use this code however you like, with the proviso that -// the author takes on no responsibility or liability for any use. +// License: Public domain. You are free to use this code however you like, with +// the proviso that the author takes on no responsibility or liability for any +// use. // // QUICK DOCUMENTATION // -// (see also the full documentation at http://sigslot.sourceforge.net/) +// (see also the full documentation at http://sigslot.sourceforge.net/) // -// #define switches -// SIGSLOT_PURE_ISO - Define this to force ISO C++ compliance. This also disables -// all of the thread safety support on platforms where it is -// available. +// #define switches +// SIGSLOT_PURE_ISO: +// Define this to force ISO C++ compliance. This also disables all of +// the thread safety support on platforms where it is available. // -// SIGSLOT_USE_POSIX_THREADS - Force use of Posix threads when using a C++ compiler other than -// gcc on a platform that supports Posix threads. (When using gcc, -// this is the default - use SIGSLOT_PURE_ISO to disable this if -// necessary) +// SIGSLOT_USE_POSIX_THREADS: +// Force use of Posix threads when using a C++ compiler other than gcc +// on a platform that supports Posix threads. (When using gcc, this is +// the default - use SIGSLOT_PURE_ISO to disable this if necessary) // -// SIGSLOT_DEFAULT_MT_POLICY - Where thread support is enabled, this defaults to multi_threaded_global. -// Otherwise, the default is single_threaded. #define this yourself to -// override the default. In pure ISO mode, anything other than -// single_threaded will cause a compiler error. +// SIGSLOT_DEFAULT_MT_POLICY: +// Where thread support is enabled, this defaults to +// multi_threaded_global. Otherwise, the default is single_threaded. +// #define this yourself to override the default. In pure ISO mode, +// anything other than single_threaded will cause a compiler error. // -// PLATFORM NOTES +// PLATFORM NOTES // -// Win32 - On Win32, the WEBRTC_WIN symbol must be #defined. Most mainstream -// compilers do this by default, but you may need to define it -// yourself if your build environment is less standard. This causes -// the Win32 thread support to be compiled in and used automatically. +// Win32: +// On Win32, the WEBRTC_WIN symbol must be #defined. Most mainstream +// compilers do this by default, but you may need to define it yourself +// if your build environment is less standard. This causes the Win32 +// thread support to be compiled in and used automatically. // -// Unix/Linux/BSD, etc. - If you're using gcc, it is assumed that you have Posix threads -// available, so they are used automatically. You can override this -// (as under Windows) with the SIGSLOT_PURE_ISO switch. If you're using -// something other than gcc but still want to use Posix threads, you -// need to #define SIGSLOT_USE_POSIX_THREADS. +// Unix/Linux/BSD, etc.: +// If you're using gcc, it is assumed that you have Posix threads +// available, so they are used automatically. You can override this (as +// under Windows) with the SIGSLOT_PURE_ISO switch. If you're using +// something other than gcc but still want to use Posix threads, you +// need to #define SIGSLOT_USE_POSIX_THREADS. // -// ISO C++ - If none of the supported platforms are detected, or if -// SIGSLOT_PURE_ISO is defined, all multithreading support is turned off, -// along with any code that might cause a pure ISO C++ environment to -// complain. Before you ask, gcc -ansi -pedantic won't compile this -// library, but gcc -ansi is fine. Pedantic mode seems to throw a lot of -// errors that aren't really there. If you feel like investigating this, -// please contact the author. +// ISO C++: +// If none of the supported platforms are detected, or if +// SIGSLOT_PURE_ISO is defined, all multithreading support is turned +// off, along with any code that might cause a pure ISO C++ environment +// to complain. Before you ask, gcc -ansi -pedantic won't compile this +// library, but gcc -ansi is fine. Pedantic mode seems to throw a lot of +// errors that aren't really there. If you feel like investigating this, +// please contact the author. // // -// THREADING MODES +// THREADING MODES // -// single_threaded - Your program is assumed to be single threaded from the point of view -// of signal/slot usage (i.e. all objects using signals and slots are -// created and destroyed from a single thread). Behaviour if objects are -// destroyed concurrently is undefined (i.e. you'll get the occasional -// segmentation fault/memory exception). +// single_threaded: +// Your program is assumed to be single threaded from the point of view +// of signal/slot usage (i.e. all objects using signals and slots are +// created and destroyed from a single thread). Behaviour if objects are +// destroyed concurrently is undefined (i.e. you'll get the occasional +// segmentation fault/memory exception). // -// multi_threaded_global - Your program is assumed to be multi threaded. Objects using signals and -// slots can be safely created and destroyed from any thread, even when -// connections exist. In multi_threaded_global mode, this is achieved by a -// single global mutex (actually a critical section on Windows because they -// are faster). This option uses less OS resources, but results in more -// opportunities for contention, possibly resulting in more context switches -// than are strictly necessary. +// multi_threaded_global: +// Your program is assumed to be multi threaded. Objects using signals +// and slots can be safely created and destroyed from any thread, even +// when connections exist. In multi_threaded_global mode, this is +// achieved by a single global mutex (actually a critical section on +// Windows because they are faster). This option uses less OS resources, +// but results in more opportunities for contention, possibly resulting +// in more context switches than are strictly necessary. // -// multi_threaded_local - Behaviour in this mode is essentially the same as multi_threaded_global, -// except that each signal, and each object that inherits has_slots, all -// have their own mutex/critical section. In practice, this means that -// mutex collisions (and hence context switches) only happen if they are -// absolutely essential. However, on some platforms, creating a lot of -// mutexes can slow down the whole OS, so use this option with care. +// multi_threaded_local: +// Behaviour in this mode is essentially the same as +// multi_threaded_global, except that each signal, and each object that +// inherits has_slots, all have their own mutex/critical section. In +// practice, this means that mutex collisions (and hence context +// switches) only happen if they are absolutely essential. However, on +// some platforms, creating a lot of mutexes can slow down the whole OS, +// so use this option with care. // -// USING THE LIBRARY -// -// See the full documentation at http://sigslot.sourceforge.net/ +// USING THE LIBRARY // +// See the full documentation at http://sigslot.sourceforge.net/ // // Libjingle specific: +// // This file has been modified such that has_slots and signalx do not have to be // using the same threading requirements. E.g. it is possible to connect a // has_slots and signal0 or @@ -87,600 +96,552 @@ #ifndef WEBRTC_BASE_SIGSLOT_H__ #define WEBRTC_BASE_SIGSLOT_H__ +#include #include #include #include -#include // On our copy of sigslot.h, we set single threading as default. #define SIGSLOT_DEFAULT_MT_POLICY single_threaded -#if defined(SIGSLOT_PURE_ISO) || (!defined(WEBRTC_WIN) && !defined(__GNUG__) && !defined(SIGSLOT_USE_POSIX_THREADS)) -# define _SIGSLOT_SINGLE_THREADED +#if defined(SIGSLOT_PURE_ISO) || \ + (!defined(WEBRTC_WIN) && !defined(__GNUG__) && \ + !defined(SIGSLOT_USE_POSIX_THREADS)) +#define _SIGSLOT_SINGLE_THREADED #elif defined(WEBRTC_WIN) -# define _SIGSLOT_HAS_WIN32_THREADS -# if !defined(WIN32_LEAN_AND_MEAN) -# define WIN32_LEAN_AND_MEAN -# endif -# include "webrtc/base/win32.h" +#define _SIGSLOT_HAS_WIN32_THREADS +#if !defined(WIN32_LEAN_AND_MEAN) +#define WIN32_LEAN_AND_MEAN +#endif +#include "webrtc/base/win32.h" #elif defined(__GNUG__) || defined(SIGSLOT_USE_POSIX_THREADS) -# define _SIGSLOT_HAS_POSIX_THREADS -# include +#define _SIGSLOT_HAS_POSIX_THREADS +#include #else -# define _SIGSLOT_SINGLE_THREADED +#define _SIGSLOT_SINGLE_THREADED #endif #ifndef SIGSLOT_DEFAULT_MT_POLICY -# ifdef _SIGSLOT_SINGLE_THREADED -# define SIGSLOT_DEFAULT_MT_POLICY single_threaded -# else -# define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local -# endif +#ifdef _SIGSLOT_SINGLE_THREADED +#define SIGSLOT_DEFAULT_MT_POLICY single_threaded +#else +#define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local +#endif #endif // TODO: change this namespace to rtc? namespace sigslot { - class single_threaded - { - public: - void lock() {} - void unlock() {} - }; +class single_threaded { + public: + void lock() {} + void unlock() {} +}; #ifdef _SIGSLOT_HAS_WIN32_THREADS - // The multi threading policies only get compiled in if they are enabled. - class multi_threaded_global - { - public: - multi_threaded_global() - { - static bool isinitialised = false; +// The multi threading policies only get compiled in if they are enabled. +class multi_threaded_global { + public: + multi_threaded_global() { + static bool isinitialised = false; - if(!isinitialised) - { - InitializeCriticalSection(get_critsec()); - isinitialised = true; - } - } + if (!isinitialised) { + InitializeCriticalSection(get_critsec()); + isinitialised = true; + } + } - void lock() - { - EnterCriticalSection(get_critsec()); - } + void lock() { EnterCriticalSection(get_critsec()); } - void unlock() - { - LeaveCriticalSection(get_critsec()); - } + void unlock() { LeaveCriticalSection(get_critsec()); } - private: - CRITICAL_SECTION* get_critsec() - { - static CRITICAL_SECTION g_critsec; - return &g_critsec; - } - }; + private: + CRITICAL_SECTION* get_critsec() { + static CRITICAL_SECTION g_critsec; + return &g_critsec; + } +}; - class multi_threaded_local - { - public: - multi_threaded_local() - { - InitializeCriticalSection(&m_critsec); - } +class multi_threaded_local { + public: + multi_threaded_local() { InitializeCriticalSection(&m_critsec); } - multi_threaded_local(const multi_threaded_local&) - { - InitializeCriticalSection(&m_critsec); - } + multi_threaded_local(const multi_threaded_local&) { + InitializeCriticalSection(&m_critsec); + } - ~multi_threaded_local() - { - DeleteCriticalSection(&m_critsec); - } + ~multi_threaded_local() { DeleteCriticalSection(&m_critsec); } - void lock() - { - EnterCriticalSection(&m_critsec); - } + void lock() { EnterCriticalSection(&m_critsec); } - void unlock() - { - LeaveCriticalSection(&m_critsec); - } + void unlock() { LeaveCriticalSection(&m_critsec); } - private: - CRITICAL_SECTION m_critsec; - }; -#endif // _SIGSLOT_HAS_WIN32_THREADS + private: + CRITICAL_SECTION m_critsec; +}; +#endif // _SIGSLOT_HAS_WIN32_THREADS #ifdef _SIGSLOT_HAS_POSIX_THREADS - // The multi threading policies only get compiled in if they are enabled. - class multi_threaded_global - { - public: - void lock() - { - pthread_mutex_lock(get_mutex()); - } - void unlock() - { - pthread_mutex_unlock(get_mutex()); - } +// The multi threading policies only get compiled in if they are enabled. +class multi_threaded_global { + public: + void lock() { pthread_mutex_lock(get_mutex()); } + void unlock() { pthread_mutex_unlock(get_mutex()); } - private: - static pthread_mutex_t* get_mutex(); - }; + private: + static pthread_mutex_t* get_mutex(); +}; - class multi_threaded_local - { - public: - multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); } - multi_threaded_local(const multi_threaded_local&) { - pthread_mutex_init(&m_mutex, nullptr); - } - ~multi_threaded_local() - { - pthread_mutex_destroy(&m_mutex); - } - void lock() - { - pthread_mutex_lock(&m_mutex); - } - void unlock() - { - pthread_mutex_unlock(&m_mutex); - } +class multi_threaded_local { + public: + multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); } + multi_threaded_local(const multi_threaded_local&) { + pthread_mutex_init(&m_mutex, nullptr); + } + ~multi_threaded_local() { pthread_mutex_destroy(&m_mutex); } + void lock() { pthread_mutex_lock(&m_mutex); } + void unlock() { pthread_mutex_unlock(&m_mutex); } - private: - pthread_mutex_t m_mutex; - }; -#endif // _SIGSLOT_HAS_POSIX_THREADS + private: + pthread_mutex_t m_mutex; +}; +#endif // _SIGSLOT_HAS_POSIX_THREADS - template - class lock_block - { - public: - mt_policy *m_mutex; +template +class lock_block { + public: + mt_policy* m_mutex; - lock_block(mt_policy *mtx) - : m_mutex(mtx) - { - m_mutex->lock(); - } + lock_block(mt_policy* mtx) : m_mutex(mtx) { m_mutex->lock(); } - ~lock_block() - { - m_mutex->unlock(); - } - }; + ~lock_block() { m_mutex->unlock(); } +}; - class _signal_base_interface; +class _signal_base_interface; - class has_slots_interface - { - private: - typedef void (*signal_connect_t)(has_slots_interface* self, _signal_base_interface* sender); - typedef void (*signal_disconnect_t)(has_slots_interface* self, _signal_base_interface* sender); - typedef void (*disconnect_all_t)(has_slots_interface* self); +class has_slots_interface { + private: + typedef void (*signal_connect_t)(has_slots_interface* self, + _signal_base_interface* sender); + typedef void (*signal_disconnect_t)(has_slots_interface* self, + _signal_base_interface* sender); + typedef void (*disconnect_all_t)(has_slots_interface* self); - const signal_connect_t m_signal_connect; - const signal_disconnect_t m_signal_disconnect; - const disconnect_all_t m_disconnect_all; + const signal_connect_t m_signal_connect; + const signal_disconnect_t m_signal_disconnect; + const disconnect_all_t m_disconnect_all; - protected: - has_slots_interface(signal_connect_t conn, signal_disconnect_t disc, disconnect_all_t disc_all) : - m_signal_connect(conn), m_signal_disconnect(disc), m_disconnect_all(disc_all) - { - } + protected: + has_slots_interface(signal_connect_t conn, + signal_disconnect_t disc, + disconnect_all_t disc_all) + : m_signal_connect(conn), + m_signal_disconnect(disc), + m_disconnect_all(disc_all) {} - // Doesn't really need to be virtual, but is for backwards compatibility - // (it was virtual in a previous version of sigslot). - virtual ~has_slots_interface() {} + // Doesn't really need to be virtual, but is for backwards compatibility + // (it was virtual in a previous version of sigslot). + virtual ~has_slots_interface() {} - public: - void signal_connect(_signal_base_interface* sender) - { - m_signal_connect(this, sender); - } + public: + void signal_connect(_signal_base_interface* sender) { + m_signal_connect(this, sender); + } - void signal_disconnect(_signal_base_interface* sender) - { - m_signal_disconnect(this, sender); - } + void signal_disconnect(_signal_base_interface* sender) { + m_signal_disconnect(this, sender); + } - void disconnect_all() - { - m_disconnect_all(this); - } - }; + void disconnect_all() { m_disconnect_all(this); } +}; - class _signal_base_interface - { - private: - typedef void (*slot_disconnect_t)(_signal_base_interface* self, has_slots_interface* pslot); - typedef void (*slot_duplicate_t)(_signal_base_interface* self, const has_slots_interface* poldslot, has_slots_interface* pnewslot); +class _signal_base_interface { + private: + typedef void (*slot_disconnect_t)(_signal_base_interface* self, + has_slots_interface* pslot); + typedef void (*slot_duplicate_t)(_signal_base_interface* self, + const has_slots_interface* poldslot, + has_slots_interface* pnewslot); - const slot_disconnect_t m_slot_disconnect; - const slot_duplicate_t m_slot_duplicate; + const slot_disconnect_t m_slot_disconnect; + const slot_duplicate_t m_slot_duplicate; - protected: - _signal_base_interface(slot_disconnect_t disc, slot_duplicate_t dupl) : - m_slot_disconnect(disc), m_slot_duplicate(dupl) - { - } + protected: + _signal_base_interface(slot_disconnect_t disc, slot_duplicate_t dupl) + : m_slot_disconnect(disc), m_slot_duplicate(dupl) {} - ~_signal_base_interface() {} + ~_signal_base_interface() {} - public: - void slot_disconnect(has_slots_interface* pslot) - { - m_slot_disconnect(this, pslot); - } + public: + void slot_disconnect(has_slots_interface* pslot) { + m_slot_disconnect(this, pslot); + } - void slot_duplicate(const has_slots_interface* poldslot, has_slots_interface* pnewslot) - { - m_slot_duplicate(this, poldslot, pnewslot); - } - }; + void slot_duplicate(const has_slots_interface* poldslot, + has_slots_interface* pnewslot) { + m_slot_duplicate(this, poldslot, pnewslot); + } +}; - class _opaque_connection - { - private: - typedef void (*emit_t)(const _opaque_connection*); - template< typename FromT, typename ToT > - union union_caster - { - FromT from; - ToT to; - }; +class _opaque_connection { + private: + typedef void (*emit_t)(const _opaque_connection*); + template + union union_caster { + FromT from; + ToT to; + }; - emit_t pemit; - has_slots_interface* pdest; - // Pointers to member functions may be up to 16 bytes for virtual classes, - // so make sure we have enough space to store it. - unsigned char pmethod[16]; + emit_t pemit; + has_slots_interface* pdest; + // Pointers to member functions may be up to 16 bytes for virtual classes, + // so make sure we have enough space to store it. + unsigned char pmethod[16]; - public: - template< typename DestT, typename ... Args > - _opaque_connection(DestT* pd, void (DestT::*pm)(Args...)) : pdest(pd) - { - typedef void (DestT::*pm_t)(Args...); - static_assert(sizeof(pm_t) <= sizeof(pmethod), "Size of slot function pointer too large."); + public: + template + _opaque_connection(DestT* pd, void (DestT::*pm)(Args...)) : pdest(pd) { + typedef void (DestT::*pm_t)(Args...); + static_assert(sizeof(pm_t) <= sizeof(pmethod), + "Size of slot function pointer too large."); - std::memcpy(pmethod, &pm, sizeof(pm_t)); + std::memcpy(pmethod, &pm, sizeof(pm_t)); - typedef void (*em_t)(const _opaque_connection* self, Args...); - union_caster< em_t, emit_t > caster2; - caster2.from = &_opaque_connection::emitter< DestT, Args... >; - pemit = caster2.to; - } + typedef void (*em_t)(const _opaque_connection* self, Args...); + union_caster caster2; + caster2.from = &_opaque_connection::emitter; + pemit = caster2.to; + } - has_slots_interface* getdest() const { return pdest; } + has_slots_interface* getdest() const { return pdest; } - _opaque_connection duplicate(has_slots_interface* newtarget) const - { - _opaque_connection res = *this; - res.pdest = newtarget; - return res; - } + _opaque_connection duplicate(has_slots_interface* newtarget) const { + _opaque_connection res = *this; + res.pdest = newtarget; + return res; + } - // Just calls the stored "emitter" function pointer stored at construction - // time. - template< typename ... Args > - void emit(Args... args) const - { - typedef void (*em_t)(const _opaque_connection*, Args...); - union_caster< emit_t, em_t > caster; - caster.from = pemit; - (caster.to)(this, args...); - } + // Just calls the stored "emitter" function pointer stored at construction + // time. + template + void emit(Args... args) const { + typedef void (*em_t)(const _opaque_connection*, Args...); + union_caster caster; + caster.from = pemit; + (caster.to)(this, args...); + } - private: - template< typename DestT, typename ... Args > - static void emitter(const _opaque_connection* self, Args... args) - { - typedef void (DestT::*pm_t)(Args...); - pm_t pm; - std::memcpy(&pm, self->pmethod, sizeof(pm_t)); - (static_cast< DestT* >(self->pdest)->*(pm))(args...); - } - }; + private: + template + static void emitter(const _opaque_connection* self, Args... args) { + typedef void (DestT::*pm_t)(Args...); + pm_t pm; + std::memcpy(&pm, self->pmethod, sizeof(pm_t)); + (static_cast(self->pdest)->*(pm))(args...); + } +}; - template - class _signal_base : public _signal_base_interface, public mt_policy - { - protected: - typedef std::list< _opaque_connection > connections_list; +template +class _signal_base : public _signal_base_interface, public mt_policy { + protected: + typedef std::list<_opaque_connection> connections_list; - _signal_base() : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate), - m_current_iterator(m_connected_slots.end()) - { - } + _signal_base() + : _signal_base_interface(&_signal_base::do_slot_disconnect, + &_signal_base::do_slot_duplicate), + m_current_iterator(m_connected_slots.end()) {} - ~_signal_base() - { - disconnect_all(); - } + ~_signal_base() { disconnect_all(); } - private: - _signal_base& operator= (_signal_base const& that); + private: + _signal_base& operator=(_signal_base const& that); - public: - _signal_base(const _signal_base& o) : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate), - m_current_iterator(m_connected_slots.end()) { - lock_block lock(this); - for (const auto& connection : o.m_connected_slots) - { - connection.getdest()->signal_connect(this); - m_connected_slots.push_back(connection); - } - } + public: + _signal_base(const _signal_base& o) + : _signal_base_interface(&_signal_base::do_slot_disconnect, + &_signal_base::do_slot_duplicate), + m_current_iterator(m_connected_slots.end()) { + lock_block lock(this); + for (const auto& connection : o.m_connected_slots) { + connection.getdest()->signal_connect(this); + m_connected_slots.push_back(connection); + } + } - bool is_empty() - { - lock_block lock(this); - return m_connected_slots.empty(); - } + bool is_empty() { + lock_block lock(this); + return m_connected_slots.empty(); + } - void disconnect_all() - { - lock_block lock(this); + void disconnect_all() { + lock_block lock(this); - while(!m_connected_slots.empty()) - { - has_slots_interface* pdest = m_connected_slots.front().getdest(); - m_connected_slots.pop_front(); - pdest->signal_disconnect(static_cast< _signal_base_interface* >(this)); - } - // If disconnect_all is called while the signal is firing, advance the - // current slot iterator to the end to avoid an invalidated iterator from - // being dereferenced. - m_current_iterator = m_connected_slots.end(); - } + while (!m_connected_slots.empty()) { + has_slots_interface* pdest = m_connected_slots.front().getdest(); + m_connected_slots.pop_front(); + pdest->signal_disconnect(static_cast<_signal_base_interface*>(this)); + } + // If disconnect_all is called while the signal is firing, advance the + // current slot iterator to the end to avoid an invalidated iterator from + // being dereferenced. + m_current_iterator = m_connected_slots.end(); + } #if !defined(NDEBUG) - bool connected(has_slots_interface* pclass) - { - lock_block lock(this); - connections_list::const_iterator it = m_connected_slots.begin(); - connections_list::const_iterator itEnd = m_connected_slots.end(); - while(it != itEnd) - { - if (it->getdest() == pclass) - return true; - ++it; - } - return false; - } + bool connected(has_slots_interface* pclass) { + lock_block lock(this); + connections_list::const_iterator it = m_connected_slots.begin(); + connections_list::const_iterator itEnd = m_connected_slots.end(); + while (it != itEnd) { + if (it->getdest() == pclass) + return true; + ++it; + } + return false; + } #endif - void disconnect(has_slots_interface* pclass) - { - lock_block lock(this); - connections_list::iterator it = m_connected_slots.begin(); - connections_list::iterator itEnd = m_connected_slots.end(); + void disconnect(has_slots_interface* pclass) { + lock_block lock(this); + connections_list::iterator it = m_connected_slots.begin(); + connections_list::iterator itEnd = m_connected_slots.end(); - while(it != itEnd) - { - if(it->getdest() == pclass) - { - // If we're currently using this iterator because the signal is - // firing, advance it to avoid it being invalidated. - if (m_current_iterator == it) { - m_current_iterator = m_connected_slots.erase(it); - } else { - m_connected_slots.erase(it); - } - pclass->signal_disconnect(static_cast< _signal_base_interface* >(this)); - return; - } - - ++it; - } - } - - private: - static void do_slot_disconnect(_signal_base_interface* p, has_slots_interface* pslot) - { - _signal_base* const self = static_cast< _signal_base* >(p); - lock_block lock(self); - connections_list::iterator it = self->m_connected_slots.begin(); - connections_list::iterator itEnd = self->m_connected_slots.end(); - - while(it != itEnd) - { - connections_list::iterator itNext = it; - ++itNext; - - if(it->getdest() == pslot) - { - // If we're currently using this iterator because the signal is - // firing, advance it to avoid it being invalidated. - if (self->m_current_iterator == it) { - self->m_current_iterator = self->m_connected_slots.erase(it); - } else { - self->m_connected_slots.erase(it); - } + while (it != itEnd) { + if (it->getdest() == pclass) { + // If we're currently using this iterator because the signal is firing, + // advance it to avoid it being invalidated. + if (m_current_iterator == it) { + m_current_iterator = m_connected_slots.erase(it); + } else { + m_connected_slots.erase(it); } + pclass->signal_disconnect(static_cast<_signal_base_interface*>(this)); + return; + } + ++it; + } + } - it = itNext; - } - } + private: + static void do_slot_disconnect(_signal_base_interface* p, + has_slots_interface* pslot) { + _signal_base* const self = static_cast<_signal_base*>(p); + lock_block lock(self); + connections_list::iterator it = self->m_connected_slots.begin(); + connections_list::iterator itEnd = self->m_connected_slots.end(); - static void do_slot_duplicate(_signal_base_interface* p, const has_slots_interface* oldtarget, has_slots_interface* newtarget) - { - _signal_base* const self = static_cast< _signal_base* >(p); - lock_block lock(self); - connections_list::iterator it = self->m_connected_slots.begin(); - connections_list::iterator itEnd = self->m_connected_slots.end(); + while (it != itEnd) { + connections_list::iterator itNext = it; + ++itNext; - while(it != itEnd) - { - if(it->getdest() == oldtarget) - { - self->m_connected_slots.push_back(it->duplicate(newtarget)); - } + if (it->getdest() == pslot) { + // If we're currently using this iterator because the signal is firing, + // advance it to avoid it being invalidated. + if (self->m_current_iterator == it) { + self->m_current_iterator = self->m_connected_slots.erase(it); + } else { + self->m_connected_slots.erase(it); + } + } - ++it; - } - } + it = itNext; + } + } - protected: - connections_list m_connected_slots; + static void do_slot_duplicate(_signal_base_interface* p, + const has_slots_interface* oldtarget, + has_slots_interface* newtarget) { + _signal_base* const self = static_cast<_signal_base*>(p); + lock_block lock(self); + connections_list::iterator it = self->m_connected_slots.begin(); + connections_list::iterator itEnd = self->m_connected_slots.end(); - // Used to handle a slot being disconnected while a signal is - // firing (iterating m_connected_slots). - connections_list::iterator m_current_iterator; - }; + while (it != itEnd) { + if (it->getdest() == oldtarget) { + self->m_connected_slots.push_back(it->duplicate(newtarget)); + } - template - class has_slots : public has_slots_interface, public mt_policy - { - private: - typedef std::set< _signal_base_interface* > sender_set; - typedef sender_set::const_iterator const_iterator; + ++it; + } + } - public: - has_slots() : has_slots_interface(&has_slots::do_signal_connect, &has_slots::do_signal_disconnect, &has_slots::do_disconnect_all) - { - } + protected: + connections_list m_connected_slots; - has_slots(has_slots const& o) : has_slots_interface(&has_slots::do_signal_connect, &has_slots::do_signal_disconnect, &has_slots::do_disconnect_all) - { - lock_block lock(this); - for (auto* sender : o.m_senders) { - sender->slot_duplicate(&o, this); - m_senders.insert(sender); + // Used to handle a slot being disconnected while a signal is + // firing (iterating m_connected_slots). + connections_list::iterator m_current_iterator; + bool m_erase_current_iterator = false; +}; + +template +class has_slots : public has_slots_interface, public mt_policy { + private: + typedef std::set<_signal_base_interface*> sender_set; + typedef sender_set::const_iterator const_iterator; + + public: + has_slots() + : has_slots_interface(&has_slots::do_signal_connect, + &has_slots::do_signal_disconnect, + &has_slots::do_disconnect_all) {} + + has_slots(has_slots const& o) + : has_slots_interface(&has_slots::do_signal_connect, + &has_slots::do_signal_disconnect, + &has_slots::do_disconnect_all) { + lock_block lock(this); + for (auto* sender : o.m_senders) { + sender->slot_duplicate(&o, this); + m_senders.insert(sender); + } + } + + ~has_slots() { this->disconnect_all(); } + + private: + has_slots& operator=(has_slots const&); + + static void do_signal_connect(has_slots_interface* p, + _signal_base_interface* sender) { + has_slots* const self = static_cast(p); + lock_block lock(self); + self->m_senders.insert(sender); + } + + static void do_signal_disconnect(has_slots_interface* p, + _signal_base_interface* sender) { + has_slots* const self = static_cast(p); + lock_block lock(self); + self->m_senders.erase(sender); + } + + static void do_disconnect_all(has_slots_interface* p) { + has_slots* const self = static_cast(p); + lock_block lock(self); + while (!self->m_senders.empty()) { + std::set<_signal_base_interface*> senders; + senders.swap(self->m_senders); + const_iterator it = senders.begin(); + const_iterator itEnd = senders.end(); + + while (it != itEnd) { + _signal_base_interface* s = *it; + ++it; + s->slot_disconnect(p); } } + } - ~has_slots() - { - this->disconnect_all(); - } + private: + sender_set m_senders; +}; - private: - has_slots& operator= (has_slots const&); +template +class signal_with_thread_policy : public _signal_base { + private: + typedef _signal_base base; - static void do_signal_connect(has_slots_interface* p, _signal_base_interface* sender) - { - has_slots* const self = static_cast< has_slots* >(p); - lock_block lock(self); - self->m_senders.insert(sender); - } + protected: + typedef typename base::connections_list connections_list; - static void do_signal_disconnect(has_slots_interface* p, _signal_base_interface* sender) - { - has_slots* const self = static_cast< has_slots* >(p); - lock_block lock(self); - self->m_senders.erase(sender); - } + public: + signal_with_thread_policy() {} - static void do_disconnect_all(has_slots_interface* p) - { - has_slots* const self = static_cast< has_slots* >(p); - lock_block lock(self); - while (!self->m_senders.empty()) - { - std::set< _signal_base_interface* > senders; - senders.swap(self->m_senders); - const_iterator it = senders.begin(); - const_iterator itEnd = senders.end(); + template + void connect(desttype* pclass, void (desttype::*pmemfun)(Args...)) { + lock_block lock(this); + this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun)); + pclass->signal_connect(static_cast<_signal_base_interface*>(this)); + } - while(it != itEnd) - { - _signal_base_interface* s = *it; - ++it; - s->slot_disconnect(p); - } - } - } + void emit(Args... args) { + lock_block lock(this); + this->m_current_iterator = this->m_connected_slots.begin(); + while (this->m_current_iterator != this->m_connected_slots.end()) { + _opaque_connection const& conn = *this->m_current_iterator; + ++(this->m_current_iterator); + conn.emit(args...); + } + } - private: - sender_set m_senders; - }; + void operator()(Args... args) { emit(args...); } +}; - template - class signal_with_thread_policy : public _signal_base - { - private: - typedef _signal_base base; +// Alias with default thread policy. Needed because both default arguments +// and variadic template arguments must go at the end of the list, so we +// can't have both at once. +template +using signal = signal_with_thread_policy; - protected: - typedef typename base::connections_list connections_list; +// The previous verion of sigslot didn't use variadic templates, so you would +// need to write "sigslot::signal2", for example. +// Now you can just write "sigslot::signal", but these aliases +// exist for backwards compatibility. +template +using signal0 = signal_with_thread_policy; - public: - signal_with_thread_policy() - { - } +template +using signal1 = signal_with_thread_policy; - template - void connect(desttype* pclass, void (desttype::*pmemfun)(Args...)) - { - lock_block lock(this); - this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun)); - pclass->signal_connect(static_cast< _signal_base_interface* >(this)); - } +template +using signal2 = signal_with_thread_policy; - void emit(Args... args) - { - lock_block lock(this); - this->m_current_iterator = - this->m_connected_slots.begin(); - while (this->m_current_iterator != - this->m_connected_slots.end()) { - _opaque_connection const& conn = - *this->m_current_iterator; - ++(this->m_current_iterator); - conn.emit(args...); - } - } +template +using signal3 = signal_with_thread_policy; - void operator()(Args... args) - { - emit(args...); - } - }; +template +using signal4 = signal_with_thread_policy; - // Alias with default thread policy. Needed because both default arguments - // and variadic template arguments must go at the end of the list, so we - // can't have both at once. - template - using signal = signal_with_thread_policy; +template +using signal5 = signal_with_thread_policy; - // The previous verion of sigslot didn't use variadic templates, so you would - // need to write "sigslot::signal2", for example. - // Now you can just write "sigslot::signal", but these aliases - // exist for backwards compatibility. - template - using signal0 = signal_with_thread_policy; +template +using signal6 = signal_with_thread_policy; - template - using signal1 = signal_with_thread_policy; +template +using signal7 = + signal_with_thread_policy; - template - using signal2 = signal_with_thread_policy; +template +using signal8 = + signal_with_thread_policy; - template - using signal3 = signal_with_thread_policy; +} // namespace sigslot - template - using signal4 = signal_with_thread_policy; - - template - using signal5 = signal_with_thread_policy; - - template - using signal6 = signal_with_thread_policy; - - template - using signal7 = signal_with_thread_policy; - - template - using signal8 = signal_with_thread_policy; - -} // namespace sigslot - -#endif // WEBRTC_BASE_SIGSLOT_H__ +#endif // WEBRTC_BASE_SIGSLOT_H__