aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMike Buland <eichlan@xagasoft.com>2012-12-21 00:06:20 +0000
committerMike Buland <eichlan@xagasoft.com>2012-12-21 00:06:20 +0000
commit8642fe0ba100dee5a66265b07e21e043887a4a92 (patch)
tree25a0a32061a53d730d4af102c26e858b9a5344f4
parent6af2989d3abbe9ff64631df33f9f9e135274d90c (diff)
downloadlibbu++-8642fe0ba100dee5a66265b07e21e043887a4a92.tar.gz
libbu++-8642fe0ba100dee5a66265b07e21e043887a4a92.tar.bz2
libbu++-8642fe0ba100dee5a66265b07e21e043887a4a92.tar.xz
libbu++-8642fe0ba100dee5a66265b07e21e043887a4a92.zip
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.
Diffstat (limited to '')
-rw-r--r--gensigs.bld26
-rw-r--r--pregen/signals.h276
-rw-r--r--src/stable/archive.h2
-rw-r--r--src/stable/list.h5
-rw-r--r--src/tests/signal.cpp2
5 files changed, 298 insertions, 13 deletions
diff --git a/gensigs.bld b/gensigs.bld
index 6cdd5d5..6bb1e55 100644
--- a/gensigs.bld
+++ b/gensigs.bld
@@ -16,6 +16,7 @@ function genSigs( outName )
16 "#ifndef BU_SIGNALS_H\n" 16 "#ifndef BU_SIGNALS_H\n"
17 "#define BU_SIGNALS_H\n" 17 "#define BU_SIGNALS_H\n"
18 "\n" 18 "\n"
19 "#include <typeinfo>\n"
19 "#include \"bu/util.h\"\n" 20 "#include \"bu/util.h\"\n"
20 "#include \"bu/exceptionbase.h\"\n" 21 "#include \"bu/exceptionbase.h\"\n"
21 "#include \"bu/list.h\"\n" 22 "#include \"bu/list.h\"\n"
@@ -69,6 +70,7 @@ function genSigs( outName )
69 " virtual ~_Slot${i}() { }\n" 70 " virtual ~_Slot${i}() { }\n"
70 " virtual ret operator()( ${funcParams} )=0;\n" 71 " virtual ret operator()( ${funcParams} )=0;\n"
71 " virtual _Slot${i}<${templCallParams}> *clone() const=0;\n" 72 " virtual _Slot${i}<${templCallParams}> *clone() const=0;\n"
73 " virtual bool operator==( const _Slot${i}<${templCallParams}> &rhs ) const=0;\n"
72 " };\n" 74 " };\n"
73 " \n" 75 " \n"
74 " template<typename cls, ${templParams}>\n" 76 " template<typename cls, ${templParams}>\n"
@@ -89,6 +91,12 @@ function genSigs( outName )
89 " return new __Slot${i}<cls, ${templCallParams}>( pCls, pFnc );\n" 91 " return new __Slot${i}<cls, ${templCallParams}>( pCls, pFnc );\n"
90 " }\n" 92 " }\n"
91 " \n" 93 " \n"
94 " virtual bool operator==( const _Slot${i}<${templCallParams}> &rhs ) const\n"
95 " {\n"
96 " const __Slot${i}<cls, ${templCallParams}> &rrhs = (const __Slot${i}<cls, ${templCallParams}> &)rhs;\n"
97 " return pCls == rrhs.pCls && pFnc == rrhs.pFnc;\n"
98 " }\n"
99 " \n"
92 " private:\n" 100 " private:\n"
93 " cls *pCls;\n" 101 " cls *pCls;\n"
94 " ret (cls::*pFnc)( ${funcAnonParams} );\n" 102 " ret (cls::*pFnc)( ${funcAnonParams} );\n"
@@ -112,6 +120,11 @@ function genSigs( outName )
112 " return new __Slot${i}F<${templCallParams}>( pFnc );\n" 120 " return new __Slot${i}F<${templCallParams}>( pFnc );\n"
113 " }\n" 121 " }\n"
114 " \n" 122 " \n"
123 " virtual bool operator==( const _Slot${i}<${templCallParams}> &rhs ) const\n"
124 " {\n"
125 " return pFnc == ((const __Slot${i}F<${templCallParams}> &)rhs).pFnc;\n"
126 " }\n"
127 " \n"
115 " private:\n" 128 " private:\n"
116 " ret (*pFnc)( ${funcAnonParams} );\n" 129 " ret (*pFnc)( ${funcAnonParams} );\n"
117 " };\n" 130 " };\n"
@@ -141,6 +154,17 @@ function genSigs( outName )
141 " return *this;\n" 154 " return *this;\n"
142 " }\n" 155 " }\n"
143 " \n" 156 " \n"
157 " bool operator==( const Signal${i}<${templCallParams}> &rhs ) const\n"
158 " {\n"
159 " if( pCb == rhs.pCb )\n"
160 " return true;\n"
161 " if( pCb == NULL || rhs.pCb == NULL )\n"
162 " return false;\n"
163 " if( typeid(pCb) != typeid(rhs.pCb) )\n"
164 " return false;\n"
165 " return *pCb == *rhs.pCb;\n"
166 " }\n"
167 " \n"
144 " private:\n" 168 " private:\n"
145 " _Slot${i}<${templCallParams}> *pCb;\n" 169 " _Slot${i}<${templCallParams}> *pCb;\n"
146 " };\n" 170 " };\n"
@@ -187,7 +211,7 @@ function genSigs( outName )
187 " else\n" 211 " else\n"
188 " return (*i)( ${funcCallParams} );\n" 212 " return (*i)( ${funcCallParams} );\n"
189 " }\n" 213 " }\n"
190 " throw Bu::ExceptionBase(\"Empty SignalList with non-void return value called.\");\n" 214 " throw Bu::SignalException(\"Empty SignalList with non-void return value called.\");\n"
191 " }\n" 215 " }\n"
192 " };\n" 216 " };\n"
193 " \n" 217 " \n"
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 @@
8#ifndef BU_SIGNALS_H 8#ifndef BU_SIGNALS_H
9#define BU_SIGNALS_H 9#define BU_SIGNALS_H
10 10
11#include <typeinfo>
11#include "bu/util.h" 12#include "bu/util.h"
12#include "bu/exceptionbase.h" 13#include "bu/exceptionbase.h"
13#include "bu/list.h" 14#include "bu/list.h"
@@ -29,6 +30,7 @@ namespace Bu
29 virtual ~_Slot0() { } 30 virtual ~_Slot0() { }
30 virtual ret operator()( )=0; 31 virtual ret operator()( )=0;
31 virtual _Slot0<ret> *clone() const=0; 32 virtual _Slot0<ret> *clone() const=0;
33 virtual bool operator==( const _Slot0<ret> &rhs ) const=0;
32 }; 34 };
33 35
34 template<typename cls, typename ret> 36 template<typename cls, typename ret>
@@ -49,6 +51,12 @@ namespace Bu
49 return new __Slot0<cls, ret>( pCls, pFnc ); 51 return new __Slot0<cls, ret>( pCls, pFnc );
50 } 52 }
51 53
54 virtual bool operator==( const _Slot0<ret> &rhs ) const
55 {
56 const __Slot0<cls, ret> &rrhs = (const __Slot0<cls, ret> &)rhs;
57 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
58 }
59
52 private: 60 private:
53 cls *pCls; 61 cls *pCls;
54 ret (cls::*pFnc)( ); 62 ret (cls::*pFnc)( );
@@ -72,6 +80,11 @@ namespace Bu
72 return new __Slot0F<ret>( pFnc ); 80 return new __Slot0F<ret>( pFnc );
73 } 81 }
74 82
83 virtual bool operator==( const _Slot0<ret> &rhs ) const
84 {
85 return pFnc == ((const __Slot0F<ret> &)rhs).pFnc;
86 }
87
75 private: 88 private:
76 ret (*pFnc)( ); 89 ret (*pFnc)( );
77 }; 90 };
@@ -101,6 +114,17 @@ namespace Bu
101 return *this; 114 return *this;
102 } 115 }
103 116
117 bool operator==( const Signal0<ret> &rhs ) const
118 {
119 if( pCb == rhs.pCb )
120 return true;
121 if( pCb == NULL || rhs.pCb == NULL )
122 return false;
123 if( typeid(pCb) != typeid(rhs.pCb) )
124 return false;
125 return *pCb == *rhs.pCb;
126 }
127
104 private: 128 private:
105 _Slot0<ret> *pCb; 129 _Slot0<ret> *pCb;
106 }; 130 };
@@ -147,7 +171,7 @@ namespace Bu
147 else 171 else
148 return (*i)( ); 172 return (*i)( );
149 } 173 }
150 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 174 throw Bu::SignalException("Empty SignalList with non-void return value called.");
151 } 175 }
152 }; 176 };
153 177
@@ -184,6 +208,7 @@ namespace Bu
184 virtual ~_Slot1() { } 208 virtual ~_Slot1() { }
185 virtual ret operator()( p1t p1 )=0; 209 virtual ret operator()( p1t p1 )=0;
186 virtual _Slot1<ret, p1t> *clone() const=0; 210 virtual _Slot1<ret, p1t> *clone() const=0;
211 virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const=0;
187 }; 212 };
188 213
189 template<typename cls, typename ret, typename p1t> 214 template<typename cls, typename ret, typename p1t>
@@ -204,6 +229,12 @@ namespace Bu
204 return new __Slot1<cls, ret, p1t>( pCls, pFnc ); 229 return new __Slot1<cls, ret, p1t>( pCls, pFnc );
205 } 230 }
206 231
232 virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const
233 {
234 const __Slot1<cls, ret, p1t> &rrhs = (const __Slot1<cls, ret, p1t> &)rhs;
235 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
236 }
237
207 private: 238 private:
208 cls *pCls; 239 cls *pCls;
209 ret (cls::*pFnc)( p1t ); 240 ret (cls::*pFnc)( p1t );
@@ -227,6 +258,11 @@ namespace Bu
227 return new __Slot1F<ret, p1t>( pFnc ); 258 return new __Slot1F<ret, p1t>( pFnc );
228 } 259 }
229 260
261 virtual bool operator==( const _Slot1<ret, p1t> &rhs ) const
262 {
263 return pFnc == ((const __Slot1F<ret, p1t> &)rhs).pFnc;
264 }
265
230 private: 266 private:
231 ret (*pFnc)( p1t ); 267 ret (*pFnc)( p1t );
232 }; 268 };
@@ -256,6 +292,17 @@ namespace Bu
256 return *this; 292 return *this;
257 } 293 }
258 294
295 bool operator==( const Signal1<ret, p1t> &rhs ) const
296 {
297 if( pCb == rhs.pCb )
298 return true;
299 if( pCb == NULL || rhs.pCb == NULL )
300 return false;
301 if( typeid(pCb) != typeid(rhs.pCb) )
302 return false;
303 return *pCb == *rhs.pCb;
304 }
305
259 private: 306 private:
260 _Slot1<ret, p1t> *pCb; 307 _Slot1<ret, p1t> *pCb;
261 }; 308 };
@@ -302,7 +349,7 @@ namespace Bu
302 else 349 else
303 return (*i)( p1 ); 350 return (*i)( p1 );
304 } 351 }
305 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 352 throw Bu::SignalException("Empty SignalList with non-void return value called.");
306 } 353 }
307 }; 354 };
308 355
@@ -339,6 +386,7 @@ namespace Bu
339 virtual ~_Slot2() { } 386 virtual ~_Slot2() { }
340 virtual ret operator()( p1t p1, p2t p2 )=0; 387 virtual ret operator()( p1t p1, p2t p2 )=0;
341 virtual _Slot2<ret, p1t, p2t> *clone() const=0; 388 virtual _Slot2<ret, p1t, p2t> *clone() const=0;
389 virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const=0;
342 }; 390 };
343 391
344 template<typename cls, typename ret, typename p1t, typename p2t> 392 template<typename cls, typename ret, typename p1t, typename p2t>
@@ -359,6 +407,12 @@ namespace Bu
359 return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc ); 407 return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc );
360 } 408 }
361 409
410 virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const
411 {
412 const __Slot2<cls, ret, p1t, p2t> &rrhs = (const __Slot2<cls, ret, p1t, p2t> &)rhs;
413 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
414 }
415
362 private: 416 private:
363 cls *pCls; 417 cls *pCls;
364 ret (cls::*pFnc)( p1t, p2t ); 418 ret (cls::*pFnc)( p1t, p2t );
@@ -382,6 +436,11 @@ namespace Bu
382 return new __Slot2F<ret, p1t, p2t>( pFnc ); 436 return new __Slot2F<ret, p1t, p2t>( pFnc );
383 } 437 }
384 438
439 virtual bool operator==( const _Slot2<ret, p1t, p2t> &rhs ) const
440 {
441 return pFnc == ((const __Slot2F<ret, p1t, p2t> &)rhs).pFnc;
442 }
443
385 private: 444 private:
386 ret (*pFnc)( p1t, p2t ); 445 ret (*pFnc)( p1t, p2t );
387 }; 446 };
@@ -411,6 +470,17 @@ namespace Bu
411 return *this; 470 return *this;
412 } 471 }
413 472
473 bool operator==( const Signal2<ret, p1t, p2t> &rhs ) const
474 {
475 if( pCb == rhs.pCb )
476 return true;
477 if( pCb == NULL || rhs.pCb == NULL )
478 return false;
479 if( typeid(pCb) != typeid(rhs.pCb) )
480 return false;
481 return *pCb == *rhs.pCb;
482 }
483
414 private: 484 private:
415 _Slot2<ret, p1t, p2t> *pCb; 485 _Slot2<ret, p1t, p2t> *pCb;
416 }; 486 };
@@ -457,7 +527,7 @@ namespace Bu
457 else 527 else
458 return (*i)( p1, p2 ); 528 return (*i)( p1, p2 );
459 } 529 }
460 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 530 throw Bu::SignalException("Empty SignalList with non-void return value called.");
461 } 531 }
462 }; 532 };
463 533
@@ -494,6 +564,7 @@ namespace Bu
494 virtual ~_Slot3() { } 564 virtual ~_Slot3() { }
495 virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0; 565 virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0;
496 virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0; 566 virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0;
567 virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const=0;
497 }; 568 };
498 569
499 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t> 570 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
@@ -514,6 +585,12 @@ namespace Bu
514 return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc ); 585 return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc );
515 } 586 }
516 587
588 virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const
589 {
590 const __Slot3<cls, ret, p1t, p2t, p3t> &rrhs = (const __Slot3<cls, ret, p1t, p2t, p3t> &)rhs;
591 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
592 }
593
517 private: 594 private:
518 cls *pCls; 595 cls *pCls;
519 ret (cls::*pFnc)( p1t, p2t, p3t ); 596 ret (cls::*pFnc)( p1t, p2t, p3t );
@@ -537,6 +614,11 @@ namespace Bu
537 return new __Slot3F<ret, p1t, p2t, p3t>( pFnc ); 614 return new __Slot3F<ret, p1t, p2t, p3t>( pFnc );
538 } 615 }
539 616
617 virtual bool operator==( const _Slot3<ret, p1t, p2t, p3t> &rhs ) const
618 {
619 return pFnc == ((const __Slot3F<ret, p1t, p2t, p3t> &)rhs).pFnc;
620 }
621
540 private: 622 private:
541 ret (*pFnc)( p1t, p2t, p3t ); 623 ret (*pFnc)( p1t, p2t, p3t );
542 }; 624 };
@@ -566,6 +648,17 @@ namespace Bu
566 return *this; 648 return *this;
567 } 649 }
568 650
651 bool operator==( const Signal3<ret, p1t, p2t, p3t> &rhs ) const
652 {
653 if( pCb == rhs.pCb )
654 return true;
655 if( pCb == NULL || rhs.pCb == NULL )
656 return false;
657 if( typeid(pCb) != typeid(rhs.pCb) )
658 return false;
659 return *pCb == *rhs.pCb;
660 }
661
569 private: 662 private:
570 _Slot3<ret, p1t, p2t, p3t> *pCb; 663 _Slot3<ret, p1t, p2t, p3t> *pCb;
571 }; 664 };
@@ -612,7 +705,7 @@ namespace Bu
612 else 705 else
613 return (*i)( p1, p2, p3 ); 706 return (*i)( p1, p2, p3 );
614 } 707 }
615 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 708 throw Bu::SignalException("Empty SignalList with non-void return value called.");
616 } 709 }
617 }; 710 };
618 711
@@ -649,6 +742,7 @@ namespace Bu
649 virtual ~_Slot4() { } 742 virtual ~_Slot4() { }
650 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0; 743 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0;
651 virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0; 744 virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0;
745 virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const=0;
652 }; 746 };
653 747
654 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t> 748 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
@@ -669,6 +763,12 @@ namespace Bu
669 return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc ); 763 return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc );
670 } 764 }
671 765
766 virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const
767 {
768 const __Slot4<cls, ret, p1t, p2t, p3t, p4t> &rrhs = (const __Slot4<cls, ret, p1t, p2t, p3t, p4t> &)rhs;
769 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
770 }
771
672 private: 772 private:
673 cls *pCls; 773 cls *pCls;
674 ret (cls::*pFnc)( p1t, p2t, p3t, p4t ); 774 ret (cls::*pFnc)( p1t, p2t, p3t, p4t );
@@ -692,6 +792,11 @@ namespace Bu
692 return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc ); 792 return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc );
693 } 793 }
694 794
795 virtual bool operator==( const _Slot4<ret, p1t, p2t, p3t, p4t> &rhs ) const
796 {
797 return pFnc == ((const __Slot4F<ret, p1t, p2t, p3t, p4t> &)rhs).pFnc;
798 }
799
695 private: 800 private:
696 ret (*pFnc)( p1t, p2t, p3t, p4t ); 801 ret (*pFnc)( p1t, p2t, p3t, p4t );
697 }; 802 };
@@ -721,6 +826,17 @@ namespace Bu
721 return *this; 826 return *this;
722 } 827 }
723 828
829 bool operator==( const Signal4<ret, p1t, p2t, p3t, p4t> &rhs ) const
830 {
831 if( pCb == rhs.pCb )
832 return true;
833 if( pCb == NULL || rhs.pCb == NULL )
834 return false;
835 if( typeid(pCb) != typeid(rhs.pCb) )
836 return false;
837 return *pCb == *rhs.pCb;
838 }
839
724 private: 840 private:
725 _Slot4<ret, p1t, p2t, p3t, p4t> *pCb; 841 _Slot4<ret, p1t, p2t, p3t, p4t> *pCb;
726 }; 842 };
@@ -767,7 +883,7 @@ namespace Bu
767 else 883 else
768 return (*i)( p1, p2, p3, p4 ); 884 return (*i)( p1, p2, p3, p4 );
769 } 885 }
770 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 886 throw Bu::SignalException("Empty SignalList with non-void return value called.");
771 } 887 }
772 }; 888 };
773 889
@@ -804,6 +920,7 @@ namespace Bu
804 virtual ~_Slot5() { } 920 virtual ~_Slot5() { }
805 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )=0; 921 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )=0;
806 virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const=0; 922 virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const=0;
923 virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const=0;
807 }; 924 };
808 925
809 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t> 926 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
@@ -824,6 +941,12 @@ namespace Bu
824 return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc ); 941 return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc );
825 } 942 }
826 943
944 virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
945 {
946 const __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t> &rrhs = (const __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t> &)rhs;
947 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
948 }
949
827 private: 950 private:
828 cls *pCls; 951 cls *pCls;
829 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ); 952 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t );
@@ -847,6 +970,11 @@ namespace Bu
847 return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc ); 970 return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc );
848 } 971 }
849 972
973 virtual bool operator==( const _Slot5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
974 {
975 return pFnc == ((const __Slot5F<ret, p1t, p2t, p3t, p4t, p5t> &)rhs).pFnc;
976 }
977
850 private: 978 private:
851 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ); 979 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t );
852 }; 980 };
@@ -876,6 +1004,17 @@ namespace Bu
876 return *this; 1004 return *this;
877 } 1005 }
878 1006
1007 bool operator==( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rhs ) const
1008 {
1009 if( pCb == rhs.pCb )
1010 return true;
1011 if( pCb == NULL || rhs.pCb == NULL )
1012 return false;
1013 if( typeid(pCb) != typeid(rhs.pCb) )
1014 return false;
1015 return *pCb == *rhs.pCb;
1016 }
1017
879 private: 1018 private:
880 _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb; 1019 _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb;
881 }; 1020 };
@@ -922,7 +1061,7 @@ namespace Bu
922 else 1061 else
923 return (*i)( p1, p2, p3, p4, p5 ); 1062 return (*i)( p1, p2, p3, p4, p5 );
924 } 1063 }
925 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1064 throw Bu::SignalException("Empty SignalList with non-void return value called.");
926 } 1065 }
927 }; 1066 };
928 1067
@@ -959,6 +1098,7 @@ namespace Bu
959 virtual ~_Slot6() { } 1098 virtual ~_Slot6() { }
960 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )=0; 1099 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )=0;
961 virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const=0; 1100 virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const=0;
1101 virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const=0;
962 }; 1102 };
963 1103
964 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t> 1104 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
@@ -979,6 +1119,12 @@ namespace Bu
979 return new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc ); 1119 return new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc );
980 } 1120 }
981 1121
1122 virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
1123 {
1124 const __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t> &rrhs = (const __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t> &)rhs;
1125 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
1126 }
1127
982 private: 1128 private:
983 cls *pCls; 1129 cls *pCls;
984 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ); 1130 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
@@ -1002,6 +1148,11 @@ namespace Bu
1002 return new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc ); 1148 return new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc );
1003 } 1149 }
1004 1150
1151 virtual bool operator==( const _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
1152 {
1153 return pFnc == ((const __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t> &)rhs).pFnc;
1154 }
1155
1005 private: 1156 private:
1006 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ); 1157 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
1007 }; 1158 };
@@ -1031,6 +1182,17 @@ namespace Bu
1031 return *this; 1182 return *this;
1032 } 1183 }
1033 1184
1185 bool operator==( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs ) const
1186 {
1187 if( pCb == rhs.pCb )
1188 return true;
1189 if( pCb == NULL || rhs.pCb == NULL )
1190 return false;
1191 if( typeid(pCb) != typeid(rhs.pCb) )
1192 return false;
1193 return *pCb == *rhs.pCb;
1194 }
1195
1034 private: 1196 private:
1035 _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb; 1197 _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb;
1036 }; 1198 };
@@ -1077,7 +1239,7 @@ namespace Bu
1077 else 1239 else
1078 return (*i)( p1, p2, p3, p4, p5, p6 ); 1240 return (*i)( p1, p2, p3, p4, p5, p6 );
1079 } 1241 }
1080 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1242 throw Bu::SignalException("Empty SignalList with non-void return value called.");
1081 } 1243 }
1082 }; 1244 };
1083 1245
@@ -1114,6 +1276,7 @@ namespace Bu
1114 virtual ~_Slot7() { } 1276 virtual ~_Slot7() { }
1115 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )=0; 1277 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )=0;
1116 virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const=0; 1278 virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const=0;
1279 virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const=0;
1117 }; 1280 };
1118 1281
1119 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t> 1282 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
1134 return new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc ); 1297 return new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc );
1135 } 1298 }
1136 1299
1300 virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
1301 {
1302 const __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rrhs = (const __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &)rhs;
1303 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
1304 }
1305
1137 private: 1306 private:
1138 cls *pCls; 1307 cls *pCls;
1139 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ); 1308 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
@@ -1157,6 +1326,11 @@ namespace Bu
1157 return new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc ); 1326 return new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc );
1158 } 1327 }
1159 1328
1329 virtual bool operator==( const _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
1330 {
1331 return pFnc == ((const __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &)rhs).pFnc;
1332 }
1333
1160 private: 1334 private:
1161 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ); 1335 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
1162 }; 1336 };
@@ -1186,6 +1360,17 @@ namespace Bu
1186 return *this; 1360 return *this;
1187 } 1361 }
1188 1362
1363 bool operator==( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs ) const
1364 {
1365 if( pCb == rhs.pCb )
1366 return true;
1367 if( pCb == NULL || rhs.pCb == NULL )
1368 return false;
1369 if( typeid(pCb) != typeid(rhs.pCb) )
1370 return false;
1371 return *pCb == *rhs.pCb;
1372 }
1373
1189 private: 1374 private:
1190 _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb; 1375 _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb;
1191 }; 1376 };
@@ -1232,7 +1417,7 @@ namespace Bu
1232 else 1417 else
1233 return (*i)( p1, p2, p3, p4, p5, p6, p7 ); 1418 return (*i)( p1, p2, p3, p4, p5, p6, p7 );
1234 } 1419 }
1235 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1420 throw Bu::SignalException("Empty SignalList with non-void return value called.");
1236 } 1421 }
1237 }; 1422 };
1238 1423
@@ -1269,6 +1454,7 @@ namespace Bu
1269 virtual ~_Slot8() { } 1454 virtual ~_Slot8() { }
1270 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )=0; 1455 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )=0;
1271 virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const=0; 1456 virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const=0;
1457 virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const=0;
1272 }; 1458 };
1273 1459
1274 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t> 1460 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
1289 return new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc ); 1475 return new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc );
1290 } 1476 }
1291 1477
1478 virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
1479 {
1480 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;
1481 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
1482 }
1483
1292 private: 1484 private:
1293 cls *pCls; 1485 cls *pCls;
1294 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ); 1486 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
@@ -1312,6 +1504,11 @@ namespace Bu
1312 return new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc ); 1504 return new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc );
1313 } 1505 }
1314 1506
1507 virtual bool operator==( const _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
1508 {
1509 return pFnc == ((const __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &)rhs).pFnc;
1510 }
1511
1315 private: 1512 private:
1316 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ); 1513 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
1317 }; 1514 };
@@ -1341,6 +1538,17 @@ namespace Bu
1341 return *this; 1538 return *this;
1342 } 1539 }
1343 1540
1541 bool operator==( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs ) const
1542 {
1543 if( pCb == rhs.pCb )
1544 return true;
1545 if( pCb == NULL || rhs.pCb == NULL )
1546 return false;
1547 if( typeid(pCb) != typeid(rhs.pCb) )
1548 return false;
1549 return *pCb == *rhs.pCb;
1550 }
1551
1344 private: 1552 private:
1345 _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb; 1553 _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb;
1346 }; 1554 };
@@ -1387,7 +1595,7 @@ namespace Bu
1387 else 1595 else
1388 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8 ); 1596 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8 );
1389 } 1597 }
1390 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1598 throw Bu::SignalException("Empty SignalList with non-void return value called.");
1391 } 1599 }
1392 }; 1600 };
1393 1601
@@ -1424,6 +1632,7 @@ namespace Bu
1424 virtual ~_Slot9() { } 1632 virtual ~_Slot9() { }
1425 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )=0; 1633 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )=0;
1426 virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const=0; 1634 virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const=0;
1635 virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const=0;
1427 }; 1636 };
1428 1637
1429 template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t> 1638 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
1444 return new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc ); 1653 return new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc );
1445 } 1654 }
1446 1655
1656 virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
1657 {
1658 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;
1659 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
1660 }
1661
1447 private: 1662 private:
1448 cls *pCls; 1663 cls *pCls;
1449 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ); 1664 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
@@ -1467,6 +1682,11 @@ namespace Bu
1467 return new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc ); 1682 return new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc );
1468 } 1683 }
1469 1684
1685 virtual bool operator==( const _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
1686 {
1687 return pFnc == ((const __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &)rhs).pFnc;
1688 }
1689
1470 private: 1690 private:
1471 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ); 1691 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
1472 }; 1692 };
@@ -1496,6 +1716,17 @@ namespace Bu
1496 return *this; 1716 return *this;
1497 } 1717 }
1498 1718
1719 bool operator==( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs ) const
1720 {
1721 if( pCb == rhs.pCb )
1722 return true;
1723 if( pCb == NULL || rhs.pCb == NULL )
1724 return false;
1725 if( typeid(pCb) != typeid(rhs.pCb) )
1726 return false;
1727 return *pCb == *rhs.pCb;
1728 }
1729
1499 private: 1730 private:
1500 _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb; 1731 _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb;
1501 }; 1732 };
@@ -1542,7 +1773,7 @@ namespace Bu
1542 else 1773 else
1543 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9 ); 1774 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
1544 } 1775 }
1545 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1776 throw Bu::SignalException("Empty SignalList with non-void return value called.");
1546 } 1777 }
1547 }; 1778 };
1548 1779
@@ -1579,6 +1810,7 @@ namespace Bu
1579 virtual ~_Slot10() { } 1810 virtual ~_Slot10() { }
1580 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )=0; 1811 virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )=0;
1581 virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const=0; 1812 virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const=0;
1813 virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const=0;
1582 }; 1814 };
1583 1815
1584 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> 1816 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
1599 return new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc ); 1831 return new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc );
1600 } 1832 }
1601 1833
1834 virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
1835 {
1836 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;
1837 return pCls == rrhs.pCls && pFnc == rrhs.pFnc;
1838 }
1839
1602 private: 1840 private:
1603 cls *pCls; 1841 cls *pCls;
1604 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ); 1842 ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
@@ -1622,6 +1860,11 @@ namespace Bu
1622 return new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc ); 1860 return new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc );
1623 } 1861 }
1624 1862
1863 virtual bool operator==( const _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
1864 {
1865 return pFnc == ((const __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &)rhs).pFnc;
1866 }
1867
1625 private: 1868 private:
1626 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ); 1869 ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
1627 }; 1870 };
@@ -1651,6 +1894,17 @@ namespace Bu
1651 return *this; 1894 return *this;
1652 } 1895 }
1653 1896
1897 bool operator==( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs ) const
1898 {
1899 if( pCb == rhs.pCb )
1900 return true;
1901 if( pCb == NULL || rhs.pCb == NULL )
1902 return false;
1903 if( typeid(pCb) != typeid(rhs.pCb) )
1904 return false;
1905 return *pCb == *rhs.pCb;
1906 }
1907
1654 private: 1908 private:
1655 _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb; 1909 _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb;
1656 }; 1910 };
@@ -1697,7 +1951,7 @@ namespace Bu
1697 else 1951 else
1698 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ); 1952 return (*i)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
1699 } 1953 }
1700 throw Bu::ExceptionBase("Empty SignalList with non-void return value called."); 1954 throw Bu::SignalException("Empty SignalList with non-void return value called.");
1701 } 1955 }
1702 }; 1956 };
1703 1957
diff --git a/src/stable/archive.h b/src/stable/archive.h
index f98402d..5c3a055 100644
--- a/src/stable/archive.h
+++ b/src/stable/archive.h
@@ -129,7 +129,7 @@ namespace Bu
129 private: 129 private:
130 Stream &rStream; 130 Stream &rStream;
131 uint32_t nNextID; 131 uint32_t nNextID;
132 Hash<uint32_t,uint32_t> hPtrID; 132 Hash<uint32_t,ptrdiff_t> hPtrID;
133 Hash<uint32_t,List<void **> > hPtrDest; 133 Hash<uint32_t,List<void **> > hPtrDest;
134 Hash<Bu::String, Variant> hProps; 134 Hash<Bu::String, Variant> hProps;
135 }; 135 };
diff --git a/src/stable/list.h b/src/stable/list.h
index b7fb1d1..0b6329c 100644
--- a/src/stable/list.h
+++ b/src/stable/list.h
@@ -250,6 +250,11 @@ namespace Bu
250 return *this; 250 return *this;
251 } 251 }
252 252
253 MyType &operator-=( const value &v )
254 {
255 return erase( v );
256 }
257
253 MyType &operator+=( const MyType &src ) 258 MyType &operator+=( const MyType &src )
254 { 259 {
255 _hardCopy(); 260 _hardCopy();
diff --git a/src/tests/signal.cpp b/src/tests/signal.cpp
index 93519fa..62e8bd5 100644
--- a/src/tests/signal.cpp
+++ b/src/tests/signal.cpp
@@ -40,6 +40,8 @@ int main()
40 lMaths += slot(Double); 40 lMaths += slot(Double);
41 lMaths += slot(Square); 41 lMaths += slot(Square);
42 println("Math'd %1 = %2").arg( 5 ).arg( lMaths(5) ); 42 println("Math'd %1 = %2").arg( 5 ).arg( lMaths(5) );
43 lMaths -= slot(Square);
44 println("Math'd %1 = %2").arg( 5 ).arg( lMaths(5) );
43 45
44 return 0; 46 return 0;
45} 47}