Changeset 9368 in orxonox.OLD for branches/proxy/src

Timestamp:

Jul 20, 2006, 8:28:10 PM (18 years ago)

Author:

bensch

Message:

compiles everywhere (i think)

File:

• branches/proxy/src/lib/util/sigslot/signal.h (modified) (36 diffs)

branches/proxy/src/lib/util/sigslot/signal.h

@@ -95 +95 @@
   class _connection_base0
   {
-    public:
-      virtual has_slots<mt_policy>* getdest() const = 0;
-      virtual void emit() = 0;
-      virtual _connection_base0* clone() = 0;
-      virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit() = 0;
+    virtual _connection_base0* clone() = 0;
+    virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
   };
 
@@ -105 +105 @@
   class _connection_base1
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -115 +115 @@
   class _connection_base2
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -125 +125 @@
   class _connection_base3
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -135 +135 @@
   class _connection_base4
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -146 +146 @@
   class _connection_base5
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -160 +160 @@
   class _connection_base6
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -174 +174 @@
   class _connection_base7
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -188 +188 @@
   class _connection_base8
   {
-    public:
-      virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
+  public:
+    virtual has_slots<mt_policy>* 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<mt_policy>* pnewdest) = 0;
   };
 
@@ -201 +201 @@
   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();
-      }
-
-      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);
+  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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-      void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* 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;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* 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;
   };
 
@@ -312 +312 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -424 +424 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -536 +536 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -648 +648 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -761 +761 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -875 +875 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -989 +989 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -1103 +1103 @@
   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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
-      }
-
-      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);
+  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<mt_policy>* oldtarget, has_slots<mt_policy>* 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();
+    }
+
+    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());
+    }
+
+    void disconnect(has_slots<mt_policy>* 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;
-
-          ++it;
-        }
-
-        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-      }
-
-      void disconnect(has_slots<mt_policy>* 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<mt_policy>* 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)
-          {
-            m_connected_slots.erase(it);
-            //                  delete *it;
-          }
-
-          it = itNext;
-        }
-      }
-
-    protected:
-      connections_list m_connected_slots;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* 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)
+        {
+          m_connected_slots.erase(it);
+          //                    delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
   };
 
@@ -1218 +1218 @@
   class _connection0 : public _connection_base0<mt_policy>
   {
-    public:
-      _connection0()
-      {
-        pobject = NULL;
-        pmemfun = NULL;
-      }
-
-      _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
-      {
-        m_pobject = pobject;
-        m_pmemfun = pmemfun;
-      }
-
-      virtual _connection_base0<mt_policy>* clone()
-      {
-        return new _connection0<dest_type, mt_policy>(*this);
-      }
-
-      virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-      {
-        return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-      }
-
-      virtual void emit()
-      {
-        (m_pobject->*m_pmemfun)();
-      }
-
-      virtual has_slots<mt_policy>* getdest() const
-      {
-        return m_pobject;
-      }
-
-    private:
-      dest_type* m_pobject;
-      void (dest_type::* m_pmemfun)();
+  public:
+    _connection0()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base0<mt_policy>* clone()
+    {
+      return new _connection0<dest_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
+    }
+
+    virtual void emit()
+    {
+      (m_pobject->*m_pmemfun)();
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)();
   };
 
@@ -1259 +1259 @@
   class _connection1 : public _connection_base1<arg1_type, mt_policy>
   {
-    public:
-      _connection1()
-      {
-        pobject = NULL;
-        pmemfun = NULL;
-      }
-
-      _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
-      {
-        m_pobject = pobject;
-        m_pmemfun = pmemfun;
-      }
-
-      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<mt_policy>* 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<mt_policy>* getdest() const
-      {
-        return m_pobject;
-      }
-
-    private:
-      dest_type* m_pobject;
-      void (dest_type::* m_pmemfun)(arg1_type);
+  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 _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<mt_policy>* 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<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type);
   };
 
@@ -1300 +1300 @@
   class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy>
   {
-    public:
-      _connection2()
-      {
-        pobject = NULL;
-        pmemfun = NULL;
-      }
-
-      _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                   arg2_type))
-      {
-        m_pobject = pobject;
-        m_pmemfun = pmemfun;
-      }
-
-      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<mt_policy>* 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<mt_policy>* getdest() const
-      {
-        return m_pobject;
-      }
-
-    private:
-      dest_type* m_pobject;
-      void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
+  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 _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<mt_policy>* 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<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
   };
 
@@ -1342 +1342 @@
   class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>
   {
-    public:
-      _connection3()
-      {
-        pobject = NULL;
-        pmemfun = NULL;
-      }
-
-      _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                   arg2_type, arg3_type))
-      {
-        m_pobject = pobject;
-        m_pmemfun = pmemfun;
-      }
-
-      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<mt_policy>* 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<mt_policy>* getdest() const
-      {
-        return m_pobject;
-      }
-
-    private:
-      dest_type* m_pobject;
-      void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
+  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 _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<mt_policy>* 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<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
   };
 
@@ -1386 +1386 @@
         arg3_type, arg4_type, mt_policy>
   {
-    public:
-      _connection4()
-      {
-        pobject = NULL;
-        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 _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<mt_policy>* 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<mt_policy>* getdest() const
-      {
-        return m_pobject;
-      }
-
-    private:
-      dest_type* m_pobject;
-      void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
-                                    arg4_type);
+  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 _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<mt_policy>* 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<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
+                                  arg4_type);
   };
 
@@ -1432 +1432 @@
         arg3_type, arg4_type, arg5_type, mt_policy>
   {
-    public:
-      _connection5()
-      {
-        pobject = NULL;
-        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 _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<mt_policy>* 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<mt_policy>* 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);
+  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 _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<mt_policy>* 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<mt_policy>* 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);
   };
 
@@ -1482 +1482 @@
         arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>
   {
-    public:
-      _connection6()
-      {
-        pobject = NULL;
-        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 _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<mt_policy>* 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<mt_policy>* 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);
+  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 _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<mt_policy>* 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<mt_policy>* 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);
   };
 
@@ -1532 +1532 @@
         arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
   {
-    public:
-      _connection7()
-      {
-        pobject = NULL;
-        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 _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<mt_policy>* 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<mt_policy>* 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);
+  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 _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<mt_policy>* 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<mt_policy>* 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);
   };
 
@@ -1583 +1583 @@
         arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
   {
-    public:
-      _connection8()
-      {
-        pobject = NULL;
-        pmemfun = NULL;
-      }
-
-      _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                   arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                   arg7_type, arg8_type))
-      {
-        m_pobject = pobject;
-        m_pmemfun = pmemfun;
-      }
-
-      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<mt_policy>* 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<mt_policy>* 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);
+  public:
+    _connection8()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                 arg7_type, arg8_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    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<mt_policy>* 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<mt_policy>* 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);
   };
 
@@ -1632 +1632 @@
   class signal0 : public _signal_base0<mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit()
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit();
+
+        it = itNext;
+      }
+    }
+
+    void operator()()
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit();
+
+        it = itNext;
+      }
+    }
   };
 
@@ -1692 +1692 @@
   class signal1 : public _signal_base1<arg1_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -1752 +1752 @@
   class signal2 : public _signal_base2<arg1_type, arg2_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -1813 +1813 @@
   class signal3 : public _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -1876 +1876 @@
         arg4_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -1940 +1940 @@
         arg4_type, arg5_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -2009 +2009 @@
         arg4_type, arg5_type, arg6_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -2078 +2078 @@
         arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
   {
-    public:
-      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;
-        }
-      }
+  public:
+    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);
+      this->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 _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->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 _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
+
+        it = itNext;
+      }
+    }
   };
 
@@ -2148 +2148 @@
         arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
   {
-    public:
-      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);
-      }
-
-      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;
-        }
-      }
-
-      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;
-        }
-      }
+  public:
+    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);
+      this->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, arg8_type a8)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
+
+        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, arg8_type a8)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
+
+        it = itNext;
+      }
+    }
   };