Rewrite of sigslot that avoids vtables.

webrtc/base/sigslot.h

 // sigslot.h: Signal/Slot classes
 //
 // 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.
 //
 // QUICK DOCUMENTATION
 //
 //                              (see also the full documentation at http://sigslot.sourceforge.net/)
@@ skipping 105 matching lines @@
 #               define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
 #       endif
 #endif
 
 // TODO: change this namespace to rtc?
 namespace sigslot {
 
         class single_threaded
         {
         public:
-                single_threaded()
-                {
-                        ;
-                }
-
-                virtual ~single_threaded() {}
-
-                virtual void lock() {}
-
-                virtual void unlock() {}
-        };
+                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;
 
                         if(!isinitialised)
                         {
                                 InitializeCriticalSection(get_critsec());
                                 isinitialised = true;
                         }
                 }
 
-                multi_threaded_global(const multi_threaded_global&)
-                {
-                        ;
-                }
-
-                virtual ~multi_threaded_global()
-                {
-                        ;
-                }
-
-                virtual void lock()
+                void lock()
                 {
                         EnterCriticalSection(get_critsec());
                 }
 
-                virtual void unlock()
+                void unlock()
                 {
                         LeaveCriticalSection(get_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);
                 }
 
                 multi_threaded_local(const multi_threaded_local&)
                 {
                         InitializeCriticalSection(&m_critsec);
                 }
 
-                virtual ~multi_threaded_local()
+                ~multi_threaded_local()
                 {
                         DeleteCriticalSection(&m_critsec);
                 }
 
-                virtual void lock()
+                void lock()
                 {
                         EnterCriticalSection(&m_critsec);
                 }
 
-                virtual void unlock()
+                void unlock()
                 {
                         LeaveCriticalSection(&m_critsec);
                 }
 
         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:
-         multi_threaded_global();
-         multi_threaded_global(const multi_threaded_global&);
-         virtual ~multi_threaded_global();
-         virtual void lock();
-         virtual void unlock();
+                void lock()
+                {
+                        pthread_mutex_lock(&g_mutex);
+                }
+                void unlock()
+                {
+                        pthread_mutex_unlock(&g_mutex);
+                }
 
-        private:
-                pthread_mutex_t* get_mutex()
-                {
-                        static pthread_mutex_t g_mutex;
-                        return &g_mutex;
-                }
+        private:
+                static pthread_mutex_t g_mutex;
         };
 
         class multi_threaded_local
         {
         public:
-         multi_threaded_local();
-         multi_threaded_local(const multi_threaded_local&);
-         virtual ~multi_threaded_local();
-         virtual void lock();
-         virtual void unlock();
+                multi_threaded_local()
+                {
+                        pthread_mutex_init(&m_mutex, NULL);
+                }
+                multi_threaded_local(const multi_threaded_local&)
+                {
+                        pthread_mutex_init(&m_mutex, NULL);
+                }
+                ~multi_threaded_local()
+                {
+                        pthread_mutex_destroy(&m_mutex);
+                }
+                void lock()
+                {
+                        pthread_mutex_lock(&m_mutex);
+                }
+                void unlock()
+                {
+                        pthread_mutex_unlock(&m_mutex);
+                }
 
-        private:
+        private:
                 pthread_mutex_t m_mutex;
         };
 #endif // _SIGSLOT_HAS_POSIX_THREADS
 
         template<class mt_policy>
         class lock_block
         {
         public:
                 mt_policy *m_mutex;
 
                 lock_block(mt_policy *mtx)
                         : m_mutex(mtx)
                 {
                         m_mutex->lock();
                 }
 
                 ~lock_block()
                 {
                         m_mutex->unlock();
                 }
         };
 
-        class has_slots_interface;
-
-        template<class mt_policy>
-        class _connection_base0
-        {
-        public:
-                virtual ~_connection_base0() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit() = 0;
-                virtual _connection_base0* clone() = 0;
-                virtual _connection_base0* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class mt_policy>
-        class _connection_base1
-        {
-        public:
-                virtual ~_connection_base1() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type) = 0;
-                virtual _connection_base1<arg1_type, mt_policy>* clone() = 0;
-                virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class mt_policy>
-        class _connection_base2
-        {
-        public:
-                virtual ~_connection_base2() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type) = 0;
-                virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone() = 0;
-                virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class mt_policy>
-        class _connection_base3
-        {
-        public:
-                virtual ~_connection_base3() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type) = 0;
-                virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone() = 0;
-                virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
-        class _connection_base4
-        {
-        public:
-                virtual ~_connection_base4() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
-                virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone() = 0;
-                virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class mt_policy>
-        class _connection_base5
-        {
-        public:
-                virtual ~_connection_base5() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type) = 0;
-                virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>* clone() = 0;
-                virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class mt_policy>
-        class _connection_base6
-        {
-        public:
-                virtual ~_connection_base6() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                        arg6_type) = 0;
-                virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>* clone() = 0;
-                virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class mt_policy>
-        class _connection_base7
-        {
-        public:
-                virtual ~_connection_base7() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                        arg6_type, arg7_type) = 0;
-                virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>* clone() = 0;
-                virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy>
-        class _connection_base8
-        {
-        public:
-                virtual ~_connection_base8() {}
-                virtual has_slots_interface* getdest() const = 0;
-                virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                        arg6_type, arg7_type, arg8_type) = 0;
-                virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone() = 0;
-                virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots_interface* pnewdest) = 0;
+        template< bool f > struct static_assertion_result;
+        template< > struct static_assertion_result< true > { enum { value = 1 }; };
+
+        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);
+
+                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)
+                {
+                }
+
+                ~has_slots_interface() {}
+
+        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 disconnect_all()
+                {
+                        m_disconnect_all(this);
+                }
         };
 
         class _signal_base_interface
         {
-        public:
-                virtual ~_signal_base_interface() {}
-                virtual void slot_disconnect(has_slots_interface* pslot) = 0;
-                virtual void slot_duplicate(const has_slots_interface* poldslot, has_slots_interface* pnewslot) = 0;
+        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;
+
+        protected:
+                _signal_base_interface(slot_disconnect_t disc, slot_duplicate_t dupl) :
+                        m_slot_disconnect(disc), m_slot_duplicate(dupl)
+                {
+                }
+
+                ~_signal_base_interface() {}
+
+        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);
+                }
+        };
+
+        class _opaque_connection
+        {
+        private:
+                typedef void (_opaque_connection::*method_t)();
+                typedef void (*emit_t)(const _opaque_connection*);
+                template< typename FromT, typename ToT >
+                union union_caster
+                {
+                        FromT from;
+                        ToT to;
+                };
+
+                emit_t pemit;
+                has_slots_interface* pdest;
+                method_t pmethod;
+
+        public:
+                template< typename DestT >
+                _opaque_connection(DestT* pd, void (DestT::*pm)()) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)();
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit0< DestT >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit1< DestT, T0 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit2< DestT, T0, T1 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit3< DestT, T0, T1, T2 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2, T3)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2, T3);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit4< DestT, T0, T1, T2, T3 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2, T3, T4)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2, T3, T4);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit5< DestT, T0, T1, T2, T3, T4 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2, T3, T4, T5)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2, T3, T4, T5);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit6< DestT, T0, T1, T2, T3, T4, T5 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2, T3, T4, T5, T6)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5, T6);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2, T3, T4, T5, T6);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit7< DestT, T0, T1, T2, T3, T4, T5, T6 >;
+                        pemit = caster2.to;
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 >
+                _opaque_connection(DestT* pd, void (DestT::*pm)(T0, T1, T2, T3, T4, T5, T6, T7)) : pdest(pd)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5, T6, T7);
+                        enum { test = static_assertion_result< sizeof(pm_t) == sizeof(method_t) >::value };
+
+                        union_caster< pm_t, method_t > caster;
+                        caster.from = pm;
+                        pmethod = caster.to;
+
+                        typedef void (*em_t)(const _opaque_connection* self, T0, T1, T2, T3, T4, T5, T6, T7);
+                        union_caster< em_t, emit_t > caster2;
+                        caster2.from = &_opaque_connection::emit8< DestT, T0, T1, T2, T3, T4, T5, T6, T7 >;
+                        pemit = caster2.to;
+                }
+
+                has_slots_interface* getdest() const { return pdest; }
+
+                _opaque_connection duplicate(has_slots_interface* newtarget) const
+                {
+                        _opaque_connection res = *this;
+                        res.pdest = newtarget;
+                        return res;
+                }
+
+                void emit() const
+                {
+                        typedef void (*em_t)(const _opaque_connection*);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this);
+                }
+
+                template< typename T0 >
+                void emit(T0 arg0) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0);
+                }
+
+                template< typename T0, typename T1 >
+                void emit(T0 arg0, T1 arg1) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1);
+                }
+
+                template< typename T0, typename T1, typename T2 >
+                void emit(T0 arg0, T1 arg1, T2 arg2) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2);
+                }
+
+                template< typename T0, typename T1, typename T2, typename T3 >
+                void emit(T0 arg0, T1 arg1, T2 arg2, T3 arg3) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2, T3);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2, arg3);
+                }
+
+                template< typename T0, typename T1, typename T2, typename T3, typename T4 >
+                void emit(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2, T3, T4);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2, arg3, arg4);
+                }
+
+                template< typename T0, typename T1, typename T2, typename T3, typename T4, typename T5 >
+                void emit(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2, T3, T4, T5);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2, arg3, arg4, arg5);
+                }
+
+                template< typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 >
+                void emit(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2, T3, T4, T5, T6);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+                }
+
+                template< typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 >
+                void emit(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) const
+                {
+                        typedef void (*em_t)(const _opaque_connection*, T0, T1, T2, T3, T4, T5, T6, T7);
+                        union_caster< emit_t, em_t > caster;
+                        caster.from = pemit;
+                        (caster.to)(this, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+                }
+
+        private:
+                template< typename DestT >
+                static void emit0(const _opaque_connection* self)
+                {
+                        typedef void (DestT::*pm_t)();
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))();
+                }
+
+                template< typename DestT, typename T0 >
+                static void emit1(const _opaque_connection* self, T0 arg0)
+                {
+                        typedef void (DestT::*pm_t)(T0);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0);
+                }
+
+                template< typename DestT, typename T0, typename T1 >
+                static void emit2(const _opaque_connection* self, T0 arg0, T1 arg1)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2 >
+                static void emit3(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3 >
+                static void emit4(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2, T3 arg3)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2, arg3);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4 >
+                static void emit5(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2, arg3, arg4);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5 >
+                static void emit6(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2, arg3, arg4, arg5);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 >
+                static void emit7(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5, T6);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+                }
+
+                template< typename DestT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 >
+                static void emit8(const _opaque_connection* self, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+                {
+                        typedef void (DestT::*pm_t)(T0, T1, T2, T3, T4, T5, T6, T7);
+                        union_caster< method_t, pm_t > caster;
+                        caster.from = self->pmethod;
+                        (static_cast< DestT* >(self->pdest)->*(caster.to))(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+                }
         };
 
         template<class mt_policy>
         class _signal_base : public _signal_base_interface, public mt_policy
         {
-        };
-
-        class has_slots_interface
-        {
-        public:
-                has_slots_interface()
-                {
-                        ;
-                }
-
-                virtual void signal_connect(_signal_base_interface* sender) = 0;
-
-                virtual void signal_disconnect(_signal_base_interface* sender) = 0;
-
-                virtual ~has_slots_interface()
-                {
-                }
-
-                virtual void disconnect_all() = 0;
+        protected:
+                typedef std::list< _opaque_connection > connections_list;
+
+                _signal_base() : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate)
+                {
+                }
+
+                ~_signal_base()
+                {
+                        disconnect_all();
+                }
+
+        private:
+                _signal_base(const _signal_base& s);
+                _signal_base& operator= (_signal_base const& that);
+
+        public:
+                bool is_empty()
+                {
+                        lock_block<mt_policy> lock(this);
+                        return m_connected_slots.empty();
+                }
+
+                void disconnect_all()
+                {
+                        lock_block<mt_policy> 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 !defined(NDEBUG)
+                bool connected(has_slots_interface* pclass)
+                {
+                        lock_block<mt_policy> 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<mt_policy> 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)
+                                {
+                                        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<mt_policy> 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)
+                                {
+                                        self->m_connected_slots.erase(it);
+                                }
+
+                                it = itNext;
+                        }
+                }
+
+                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<mt_policy> lock(self);
+                        connections_list::iterator it = self->m_connected_slots.begin();
+                        connections_list::iterator itEnd = self->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                if(it->getdest() == oldtarget)
+                                {
+                                        self->m_connected_slots.push_back(it->duplicate(newtarget));
+                                }
+
+                                ++it;
+                        }
+                }
+
+        protected:
+                connections_list m_connected_slots;
         };
 
         template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
         class has_slots : public has_slots_interface, public mt_policy
         {
         private:
-                typedef std::set<_signal_base_interface*> sender_set;
+                typedef std::set< _signal_base_interface* > sender_set;
                 typedef sender_set::const_iterator const_iterator;
 
         public:
-                has_slots()
-                {
-                        ;
-                }
-
-                has_slots(const has_slots& hs)
-                {
-                        lock_block<mt_policy> lock(this);
-                        const_iterator it = hs.m_senders.begin();
-                        const_iterator itEnd = hs.m_senders.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->slot_duplicate(&hs, this);
-                                m_senders.insert(*it);
-                                ++it;
-                        }
-                }
-
-                void signal_connect(_signal_base_interface* sender)
-                {
-                        lock_block<mt_policy> lock(this);
-                        m_senders.insert(sender);
-                }
-
-                void signal_disconnect(_signal_base_interface* sender)
-                {
-                        lock_block<mt_policy> lock(this);
-                        m_senders.erase(sender);
-                }
-
-                virtual ~has_slots()
-                {
-                        disconnect_all();
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        const_iterator it = m_senders.begin();
-                        const_iterator itEnd = m_senders.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->slot_disconnect(this);
-                                ++it;
-                        }
-
-                        m_senders.erase(m_senders.begin(), m_senders.end());
+                has_slots() : has_slots_interface(&has_slots::do_signal_connect, &has_slots::do_signal_disconnect, &has_slots::do_disconnect_all)
+                {
+                }
+
+                ~has_slots()
+                {
+                        this->disconnect_all();
+                }
+
+        private:
+                has_slots(has_slots const&);
+                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< has_slots* >(p);
+                        lock_block<mt_policy> 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< has_slots* >(p);
+                        lock_block<mt_policy> lock(self);
+                        self->m_senders.erase(sender);
+                }
+
+                static void do_disconnect_all(has_slots_interface* p)
+                {
+                        has_slots* const self = static_cast< has_slots* >(p);
+                        lock_block<mt_policy> 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);
+                                }
+                        }
                 }
 
         private:
                 sender_set m_senders;
         };
 
-        template<class mt_policy>
-        class _signal_base0 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base0<mt_policy> *>  connections_list;
-
-                _signal_base0()
-                {
-                        ;
-                }
-
-                _signal_base0(const _signal_base0& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base0()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
-        };
-
-        template<class arg1_type, class mt_policy>
-        class _signal_base1 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base1<arg1_type, mt_policy> *>  connections_list;
-
-                _signal_base1()
-                {
-                        ;
-                }
-
-                _signal_base1(const _signal_base1<arg1_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base1()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-
-        protected:
-                connections_list m_connected_slots;
-        };
-
-        template<class arg1_type, class arg2_type, class mt_policy>
-        class _signal_base2 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *>
-                        connections_list;
-
-                _signal_base2()
-                {
-                        ;
-                }
-
-                _signal_base2(const _signal_base2<arg1_type, arg2_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base2()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class mt_policy>
-        class _signal_base3 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *>
-                        connections_list;
-
-                _signal_base3()
-                {
-                        ;
-                }
-
-                _signal_base3(const _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base3()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
-        class _signal_base4 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type,
-                        arg4_type, mt_policy> *>  connections_list;
-
-                _signal_base4()
-                {
-                        ;
-                }
-
-                _signal_base4(const _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base4()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
+
+        template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal0 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal0()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)())
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit()
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit();
+                        }
+                }
+
+                void operator()()
+                {
+                        emit();
+                }
+        };
+
+        template<class arg1_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal1 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal1()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type>(a1);
+                        }
+                }
+
+                void operator()(arg1_type a1)
+                {
+                        emit(a1);
+                }
+        };
+
+        template<class arg1_type, class arg2_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal2 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal2()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type>(a1, a2);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2)
+                {
+                        emit(a1, a2);
+                }
+        };
+
+        template<class arg1_type, class arg2_type, class arg3_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal3 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal3()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type, arg3_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2, arg3_type a3)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type>(a1, a2, a3);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
+                {
+                        emit(a1, a2, a3);
+                }
+        };
+
+        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal4 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal4()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type, arg3_type, arg4_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type, arg4_type>(a1, a2, a3, a4);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+                {
+                        emit(a1, a2, a3, a4);
+                }
         };
 
         template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class mt_policy>
-        class _signal_base5 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type,
-                        arg4_type, arg5_type, mt_policy> *>  connections_list;
-
-                _signal_base5()
-                {
-                        ;
-                }
-
-                _signal_base5(const _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base5()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
-        };
+        class arg5_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal5 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal5()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type, arg3_type, arg4_type, arg5_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type>(a1, a2, a3, a4, a5);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5)
+                {
+                        emit(a1, a2, a3, a4, a5);
+                }
+        };
+
 
         template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class mt_policy>
-        class _signal_base6 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type,
-                        arg4_type, arg5_type, arg6_type, mt_policy> *>  connections_list;
-
-                _signal_base6()
-                {
-                        ;
-                }
-
-                _signal_base6(const _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base6()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
+        class arg5_type, class arg6_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal6 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal6()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5, arg6_type a6)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type>(a1, a2, a3, a4, a5, a6);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5, arg6_type a6)
+                {
+                        emit(a1, a2, a3, a4, a5, a6);
+                }
         };
 
         template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class mt_policy>
-        class _signal_base7 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base7<arg1_type, arg2_type, arg3_type,
-                        arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *>  connections_list;
-
-                _signal_base7()
-                {
-                        ;
-                }
-
-                _signal_base7(const _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base7()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
+        class arg5_type, class arg6_type, class arg7_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal7 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal7()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                        arg7_type))
+                {
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
+                }
+
+                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5, arg6_type a6, arg7_type a7)
+                {
+                        lock_block<mt_policy> lock(this);
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type>(a1, a2, a3, a4, a5, a6, a7);
+                        }
+                }
+
+                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                        arg5_type a5, arg6_type a6, arg7_type a7)
+                {
+                        emit(a1, a2, a3, a4, a5, a6, a7);
+                }
         };
 
         template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy>
-        class _signal_base8 : public _signal_base<mt_policy>
-        {
-        public:
-                typedef std::list<_connection_base8<arg1_type, arg2_type, arg3_type,
-                        arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> *>
-                        connections_list;
-
-                _signal_base8()
-                {
-                        ;
-                }
-
-                _signal_base8(const _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
-                        : _signal_base<mt_policy>(s)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = s.m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_connect(this);
-                                m_connected_slots.push_back((*it)->clone());
-
-                                ++it;
-                        }
-                }
-
-                void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == oldtarget)
-                                {
-                                        m_connected_slots.push_back((*it)->duplicate(newtarget));
-                                }
-
-                                ++it;
-                        }
-                }
-
-                ~_signal_base8()
-                {
-                        disconnect_all();
-                }
-
-                bool is_empty()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        return it == itEnd;
-                }
-
-                void disconnect_all()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                (*it)->getdest()->signal_disconnect(this);
-                                delete *it;
-
-                                ++it;
-                        }
-
-                        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-                }
-
-#if !defined(NDEBUG)
-                        bool connected(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-                                if ((*it)->getdest() == pclass)
-                                        return true;
-                                it = itNext;
-                        }
-                        return false;
-                }
-#endif
-
-                void disconnect(has_slots_interface* pclass)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                if((*it)->getdest() == pclass)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                        pclass->signal_disconnect(this);
-                                        return;
-                                }
-
-                                ++it;
-                        }
-                }
-
-                void slot_disconnect(has_slots_interface* pslot)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::iterator it = m_connected_slots.begin();
-                        typename connections_list::iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                typename connections_list::iterator itNext = it;
-                                ++itNext;
-
-                                if((*it)->getdest() == pslot)
-                                {
-                                        delete *it;
-                                        m_connected_slots.erase(it);
-                                }
-
-                                it = itNext;
-                        }
-                }
-
-        protected:
-                connections_list m_connected_slots;
-        };
-
-
-        template<class dest_type, class mt_policy>
-        class _connection0 : public _connection_base0<mt_policy>
-        {
-        public:
-                _connection0()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection0()
-                {
-                }
-
-                virtual _connection_base0<mt_policy>* clone()
-                {
-                        return new _connection0<dest_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base0<mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit()
-                {
-                        (m_pobject->*m_pmemfun)();
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)();
-        };
-
-        template<class dest_type, class arg1_type, class mt_policy>
-        class _connection1 : public _connection_base1<arg1_type, mt_policy>
-        {
-        public:
-                _connection1()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection1()
-                {
-                }
-
-                virtual _connection_base1<arg1_type, mt_policy>* clone()
-                {
-                        return new _connection1<dest_type, arg1_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection1<dest_type, arg1_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1)
-                {
-                        (m_pobject->*m_pmemfun)(a1);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class mt_policy>
-        class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy>
-        {
-        public:
-                _connection2()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection2()
-                {
-                }
-
-                virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone()
-                {
-                        return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type, class mt_policy>
-        class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>
-        {
-        public:
-                _connection3()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection3()
-                {
-                }
-
-                virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone()
-                {
-                        return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-        class arg4_type, class mt_policy>
-        class _connection4 : public _connection_base4<arg1_type, arg2_type,
-                arg3_type, arg4_type, mt_policy>
-        {
-        public:
-                _connection4()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection4(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection4()
-                {
-                }
-
-                virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone()
-                {
-                        return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3,
-                        arg4_type a4)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
-                        arg4_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-        class arg4_type, class arg5_type, class mt_policy>
-        class _connection5 : public _connection_base5<arg1_type, arg2_type,
-                arg3_type, arg4_type, arg5_type, mt_policy>
-        {
-        public:
-                _connection5()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection5(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection5()
-                {
-                }
-
-                virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>* clone()
-                {
-                        return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-        class arg4_type, class arg5_type, class arg6_type, class mt_policy>
-        class _connection6 : public _connection_base6<arg1_type, arg2_type,
-                arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>
-        {
-        public:
-                _connection6()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection6(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection6()
-                {
-                }
-
-                virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>* clone()
-                {
-                        return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-        class arg4_type, class arg5_type, class arg6_type, class arg7_type, class mt_policy>
-        class _connection7 : public _connection_base7<arg1_type, arg2_type,
-                arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
-        {
-        public:
-                _connection7()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection7(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
-                {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection7()
-                {
-                }
-
-                virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>* clone()
-                {
-                        return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type);
-        };
-
-        template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-        class arg4_type, class arg5_type, class arg6_type, class arg7_type,
-        class arg8_type, class mt_policy>
-        class _connection8 : public _connection_base8<arg1_type, arg2_type,
-                arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
-        {
-        public:
-                _connection8()
-                {
-                        m_pobject = NULL;
-                        m_pmemfun = NULL;
-                }
-
-                _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+        class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+        class signal8 : public _signal_base<mt_policy>
+        {
+        private:
+                typedef _signal_base<mt_policy> base;
+
+        protected:
+                typedef typename base::connections_list connections_list;
+
+        public:
+                signal8()
+                {
+                }
+
+                template<class desttype>
+                void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
                         arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
                         arg7_type, arg8_type))
                 {
-                        m_pobject = pobject;
-                        m_pmemfun = pmemfun;
-                }
-
-                virtual ~_connection8()
-                {
-                }
-
-                virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone()
-                {
-                        return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(*this);
-                }
-
-                virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots_interface* pnewdest)
-                {
-                        return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-                }
-
-                virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
-                {
-                        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
-                }
-
-                virtual has_slots_interface* getdest() const
-                {
-                        return m_pobject;
-                }
-
-        private:
-                dest_type* m_pobject;
-                void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type);
-        };
-
-        template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal0 : public _signal_base0<mt_policy>
-        {
-        public:
-                typedef _signal_base0<mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal0()
-                {
-                        ;
-                }
-
-                signal0(const signal0<mt_policy>& s)
-                        : _signal_base0<mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)())
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection0<desttype, mt_policy>* conn =
-                                new _connection0<desttype, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit();
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()()
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit();
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal1 : public _signal_base1<arg1_type, mt_policy>
-        {
-        public:
-                typedef _signal_base1<arg1_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal1()
-                {
-                        ;
-                }
-
-                signal1(const signal1<arg1_type, mt_policy>& s)
-                        : _signal_base1<arg1_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection1<desttype, arg1_type, mt_policy>* conn =
-                                new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal2 : public _signal_base2<arg1_type, arg2_type, mt_policy>
-        {
-        public:
-                typedef _signal_base2<arg1_type, arg2_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal2()
-                {
-                        ;
-                }
-
-                signal2(const signal2<arg1_type, arg2_type, mt_policy>& s)
-                        : _signal_base2<arg1_type, arg2_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection2<desttype, arg1_type, arg2_type, mt_policy>* conn = new
-                                _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal3 : public _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>
-        {
-        public:
-                typedef _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal3()
-                {
-                        ;
-                }
-
-                signal3(const signal3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
-                        : _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>* conn =
-                                new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass,
-                                pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2, arg3_type a3)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal4 : public _signal_base4<arg1_type, arg2_type, arg3_type,
-                arg4_type, mt_policy>
-        {
-        public:
-                typedef _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal4()
-                {
-                        ;
-                }
-
-                signal4(const signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
-                        : _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*
-                                conn = new _connection4<desttype, arg1_type, arg2_type, arg3_type,
-                                arg4_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal5 : public _signal_base5<arg1_type, arg2_type, arg3_type,
-                arg4_type, arg5_type, mt_policy>
-        {
-        public:
-                typedef _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal5()
-                {
-                        ;
-                }
-
-                signal5(const signal5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>& s)
-                        : _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, mt_policy>* conn = new _connection5<desttype, arg1_type, arg2_type,
-                                arg3_type, arg4_type, arg5_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal6 : public _signal_base6<arg1_type, arg2_type, arg3_type,
-                arg4_type, arg5_type, arg6_type, mt_policy>
-        {
-        public:
-                typedef _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal6()
-                {
-                        ;
-                }
-
-                signal6(const signal6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>& s)
-                        : _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, mt_policy>* conn =
-                                new _connection6<desttype, arg1_type, arg2_type, arg3_type,
-                                arg4_type, arg5_type, arg6_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal7 : public _signal_base7<arg1_type, arg2_type, arg3_type,
-                arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
-        {
-        public:
-                typedef _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal7()
-                {
-                        ;
-                }
-
-                signal7(const signal7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>& s)
-                        : _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                        arg7_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, mt_policy>* conn =
-                                new _connection7<desttype, arg1_type, arg2_type, arg3_type,
-                                arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
-                }
-
-                void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
-
-                                it = itNext;
-                        }
-                }
-
-                void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7)
-                {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-        template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-        class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-        class signal8 : public _signal_base8<arg1_type, arg2_type, arg3_type,
-                arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
-        {
-        public:
-                typedef _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> base;
-                typedef typename base::connections_list connections_list;
-                using base::m_connected_slots;
-
-                signal8()
-                {
-                        ;
-                }
-
-                signal8(const signal8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
-                        : _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(s)
-                {
-                        ;
-                }
-
-                template<class desttype>
-                        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                        arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                        arg7_type, arg8_type))
-                {
-                        lock_block<mt_policy> lock(this);
-                        _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                                arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* conn =
-                                new _connection8<desttype, arg1_type, arg2_type, arg3_type,
-                                arg4_type, arg5_type, arg6_type, arg7_type,
-                                arg8_type, mt_policy>(pclass, pmemfun);
-                        m_connected_slots.push_back(conn);
-                        pclass->signal_connect(this);
+                        lock_block<mt_policy> lock(this);
+                        this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+                        pclass->signal_connect(static_cast< _signal_base_interface* >(this));
                 }
 
                 void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
                         arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
                 {
                         lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
-
-                                it = itNext;
+                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
+                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+                        while(it != itEnd)
+                        {
+                                _opaque_connection const& conn = *it;
+                                ++it;
+
+                                conn.emit<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type>(a1, a2, a3, a4, a5, a6, a7, a8);
                         }
                 }
 
                 void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
                         arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
                 {
-                        lock_block<mt_policy> lock(this);
-                        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                itNext = it;
-                                ++itNext;
-
-                                (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
-
-                                it = itNext;
-                        }
-                }
-        };
-
-}; // namespace sigslot
+                        emit(a1, a2, a3, a4, a5, a6, a7, a8);
+                }
+        };
+
+} // namespace sigslot
 
 #endif // WEBRTC_BASE_SIGSLOT_H__