Signals (slots really) are now comperable. Building two slots for the same

function or same object and method will compare as expected.

Also added a -= function to Bu::List which works just like erase.

1 files changed, 265 insertions, 11 deletions

diff --git a/pregen/signals.h b/pregen/signals.h
index e8374e3..3435986 100644
--- a/pregen/signals.h
+++ b/pregen/signals.h
@@ -8,6 +8,7 @@
 #ifndef BU_SIGNALS_H
 #define BU_SIGNALS_H
 
+#include <typeinfo>
 #include "bu/util.h"
 #include "bu/exceptionbase.h"
 #include "bu/list.h"
@@ -29,6 +30,7 @@ namespace Bu
         virtual ~_Slot0() { }
         virtual ret operator()(  )=0;
         virtual _Slot0<ret> *clone() const=0;
+        virtual bool operator==( const _Slot0<ret> &rhs ) const=0;
     };
     
     template<typename cls, typename ret>
@@ -49,6 +51,12 @@ namespace Bu
             return new __Slot0<cls, ret>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot0<ret> &rhs ) const
+        {
+            const __Slot0<cls, ret> &rrhs = (const __Slot0<cls, ret> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)(  );
@@ -72,6 +80,11 @@ namespace Bu
             return new __Slot0F<ret>( pFnc );
         }
     
+        virtual bool operator==( const _Slot0<ret> &rhs ) const
+        {
+            return pFnc == ((const __Slot0F<ret> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)(  );
     };
@@ -101,6 +114,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal0<ret> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot0<ret> *pCb;
     };
@@ -147,7 +171,7 @@ namespace Bu
                 else
                     return (*i)(  );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -184,6 +208,7 @@ namespace Bu
         virtual ~_Slot1() { }
         virtual ret operator()( p1t p1 )=0;
         virtual _Slot1<ret, p1t> *clone() const=0;
+        virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t>
@@ -204,6 +229,12 @@ namespace Bu
             return new __Slot1<cls, ret, p1t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const
+        {
+            const __Slot1<cls, ret, p1t> &rrhs = (const __Slot1<cls, ret, p1t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t );
@@ -227,6 +258,11 @@ namespace Bu
             return new __Slot1F<ret, p1t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const
+        {
+            return pFnc == ((const __Slot1F<ret, p1t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t );
     };
@@ -256,6 +292,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal1<ret, p1t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot1<ret, p1t> *pCb;
     };
@@ -302,7 +349,7 @@ namespace Bu
                 else
                     return (*i)( p1 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -339,6 +386,7 @@ namespace Bu
         virtual ~_Slot2() { }
         virtual ret operator()( p1t p1, p2t p2 )=0;
         virtual _Slot2<ret, p1t, p2t> *clone() const=0;
+        virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t>
@@ -359,6 +407,12 @@ namespace Bu
             return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const
+        {
+            const __Slot2<cls, ret, p1t, p2t> &rrhs = (const __Slot2<cls, ret, p1t, p2t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t );
@@ -382,6 +436,11 @@ namespace Bu
             return new __Slot2F<ret, p1t, p2t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const
+        {
+            return pFnc == ((const __Slot2F<ret, p1t, p2t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t );
     };
@@ -411,6 +470,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal2<ret, p1t, p2t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot2<ret, p1t, p2t> *pCb;
     };
@@ -457,7 +527,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -494,6 +564,7 @@ namespace Bu
         virtual ~_Slot3() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0;
         virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0;
+        virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
@@ -514,6 +585,12 @@ namespace Bu
             return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const
+        {
+            const __Slot3<cls, ret, p1t, p2t, p3t> &rrhs = (const __Slot3<cls, ret, p1t, p2t, p3t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t );
@@ -537,6 +614,11 @@ namespace Bu
             return new __Slot3F<ret, p1t, p2t, p3t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const
+        {
+            return pFnc == ((const __Slot3F<ret, p1t, p2t, p3t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t );
     };
@@ -566,6 +648,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal3<ret, p1t, p2t, p3t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot3<ret, p1t, p2t, p3t> *pCb;
     };
@@ -612,7 +705,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -649,6 +742,7 @@ namespace Bu
         virtual ~_Slot4() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0;
         virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0;
+        virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
@@ -669,6 +763,12 @@ namespace Bu
             return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const
+        {
+            const __Slot4<cls, ret, p1t, p2t, p3t, p4t> &rrhs = (const __Slot4<cls, ret, p1t, p2t, p3t, p4t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t );
@@ -692,6 +792,11 @@ namespace Bu
             return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const
+        {
+            return pFnc == ((const __Slot4F<ret, p1t, p2t, p3t, p4t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t );
     };
@@ -721,6 +826,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal4<ret, p1t, p2t, p3t, p4t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot4<ret, p1t, p2t, p3t, p4t> *pCb;
     };
@@ -767,7 +883,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -804,6 +920,7 @@ namespace Bu
         virtual ~_Slot5() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )=0;
         virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const=0;
+        virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
@@ -824,6 +941,12 @@ namespace Bu
             return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
+        {
+            const __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t> &rrhs = (const __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t );
@@ -847,6 +970,11 @@ namespace Bu
             return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
+        {
+            return pFnc == ((const __Slot5F<ret, p1t, p2t, p3t, p4t, p5t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t );
     };
@@ -876,6 +1004,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb;
     };
@@ -922,7 +1061,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -959,6 +1098,7 @@ namespace Bu
         virtual ~_Slot6() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )=0;
         virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const=0;
+        virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
@@ -979,6 +1119,12 @@ namespace Bu
             return new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
+        {
+            const __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t> &rrhs = (const __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
@@ -1002,6 +1148,11 @@ namespace Bu
             return new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
+        {
+            return pFnc == ((const __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
     };
@@ -1031,6 +1182,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb;
     };
@@ -1077,7 +1239,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5, p6 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -1114,6 +1276,7 @@ namespace Bu
         virtual ~_Slot7() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )=0;
         virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const=0;
+        virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
@@ -1134,6 +1297,12 @@ namespace Bu
             return new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
+        {
+            const __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rrhs = (const __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
@@ -1157,6 +1326,11 @@ namespace Bu
             return new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
+        {
+            return pFnc == ((const __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
     };
@@ -1186,6 +1360,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb;
     };
@@ -1232,7 +1417,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5, p6, p7 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -1269,6 +1454,7 @@ namespace Bu
         virtual ~_Slot8() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )=0;
         virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const=0;
+        virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
@@ -1289,6 +1475,12 @@ namespace Bu
             return new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
+        {
+            const __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rrhs = (const __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
@@ -1312,6 +1504,11 @@ namespace Bu
             return new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
+        {
+            return pFnc == ((const __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
     };
@@ -1341,6 +1538,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb;
     };
@@ -1387,7 +1595,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5, p6, p7, p8 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -1424,6 +1632,7 @@ namespace Bu
         virtual ~_Slot9() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )=0;
         virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const=0;
+        virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
@@ -1444,6 +1653,12 @@ namespace Bu
             return new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
+        {
+            const __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rrhs = (const __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
@@ -1467,6 +1682,11 @@ namespace Bu
             return new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
+        {
+            return pFnc == ((const __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
     };
@@ -1496,6 +1716,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb;
     };
@@ -1542,7 +1773,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };
     
@@ -1579,6 +1810,7 @@ namespace Bu
         virtual ~_Slot10() { }
         virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )=0;
         virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const=0;
+        virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const=0;
     };
     
     template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
@@ -1599,6 +1831,12 @@ namespace Bu
             return new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc );
         }
     
+        virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
+        {
+            const __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rrhs = (const __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &)rhs;
+            return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
+        }
+    
     private:
         cls *pCls;
         ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
@@ -1622,6 +1860,11 @@ namespace Bu
             return new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc );
         }
     
+        virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
+        {
+            return pFnc == ((const __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &)rhs).pFnc;
+        }
+    
     private:
         ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
     };
@@ -1651,6 +1894,17 @@ namespace Bu
             return *this;
         }
     
+        bool operator==( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
+        {
+            if( pCb == rhs.pCb )
+            return true;
+            if( pCb == NULL || rhs.pCb == NULL )
+            return false;
+            if( typeid(pCb) != typeid(rhs.pCb) )
+            return false;
+            return *pCb == *rhs.pCb;
+        }
+    
     private:
         _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb;
     };
@@ -1697,7 +1951,7 @@ namespace Bu
                 else
                     return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
             }
-            throw Bu::ExceptionBase("Empty SignalList with non-void return value called.");
+            throw Bu::SignalException("Empty SignalList with non-void return value called.");
         }
     };