6 files changed, 862 insertions, 0 deletions

diff --git a/src/optparser.cpp b/src/optparser.cpp
new file mode 100644
index 0000000..2046792
--- /dev/null
+++ b/src/optparser.cpp
@@ -0,0 +1,39 @@
+#include "bu/optparser.h"
+
+Bu::OptParser::OptParser()
+{
+}
+
+Bu::OptParser::~OptParser()
+{
+}
+
+void Bu::OptParser::addOption( const Option &opt )
+{
+        lOption.append( opt );
+        if( opt.cOpt != '\0' )
+                hsOption.insert( opt.cOpt, &lOption.last() );
+        if( opt.sOpt )
+                hlOption.insert( opt.sOpt, &lOption.last() );
+
+}
+
+Bu::FString Bu::OptParser::format( const Bu::FString &sIn, int iWidth,
+                int iIndent )
+{
+
+}
+
+
+//
+// Code for Bu::OptParser::Option
+//
+
+Bu::OptParser::Option::Option()
+{
+}
+
+Bu::OptParser::Option::~Option()
+{
+}
+
diff --git a/src/optparser.h b/src/optparser.h
new file mode 100644
index 0000000..39f048d
--- /dev/null
+++ b/src/optparser.h
@@ -0,0 +1,51 @@
+#ifndef BU_OPT_PARSER_H
+#define BU_OPT_PARSER_H
+
+#include "bu/fstring.h"
+#include "bu/list.h"
+#include "bu/hash.h"
+
+namespace Bu
+{
+        class OptParser
+        {
+        public:
+                class Option
+                {
+                public:
+                        Option();
+                        virtual ~Option();
+
+                        char cOpt;
+                        Bu::FString sOpt;
+                        Bu::FString sDesc;
+                };
+
+        public:
+                OptParser();
+                virtual ~OptParser();
+
+                void parse( int argc, char *argv[] );
+
+                void addOption( const Option &opt );
+
+                template<typename c>
+                void callback( c *pObj, int (c::*fnc)( int, char *[] ) )
+                {
+                        (pObj->*fnc)( 0, NULL );
+                }
+
+        private:
+                Bu::FString format( const Bu::FString &sIn, int iWidth, int iIndent );
+
+                typedef Bu::List<Option> OptionList;
+                typedef Bu::Hash<char, Option *> ShortOptionHash;
+                typedef Bu::Hash<Bu::FString, Option *> LongOptionHash;
+
+                OptionList lOption;
+                ShortOptionHash hsOption;
+                LongOptionHash hlOption;
+        };
+};
+
+#endif
diff --git a/src/signals.h b/src/signals.h
new file mode 100644
index 0000000..722f928
--- /dev/null
+++ b/src/signals.h
@@ -0,0 +1,592 @@
+#ifndef BU_OBJECT_SIGNALS_H
+#define BU_OBJECT_SIGNALS_H
+
+#include "bu/util.h"
+
+namespace Bu
+{
+        //
+        // 0 Parameters
+        //
+
+        template<typename ret>
+        class _Slot0
+        {
+        public:
+                _Slot0() { }
+                virtual ~_Slot0() { }
+
+                virtual ret operator()()=0;
+
+                virtual _Slot0<ret> *clone() const=0;
+        };
+
+        template<typename cls, typename ret>
+        class __Slot0 : public _Slot0<ret>
+        {
+        public:
+                __Slot0( cls *pCls, ret (cls::*pFnc)() ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot0() { }
+
+                virtual ret operator()()
+                {
+                        return (pCls->*pFnc)();
+                }
+                
+                virtual _Slot0<ret> *clone() const
+                {
+                        return new __Slot0<cls, ret>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)();
+        };
+
+        template<typename ret>
+        class __Slot0F : public _Slot0<ret>
+        {
+        public:
+                __Slot0F( ret (*pFnc)() ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot0F() { }
+
+                virtual ret operator()()
+                {
+                        return (*pFnc)();
+                }
+                
+                virtual _Slot0<ret> *clone() const
+                {
+                        return new __Slot0F<ret>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)();
+        };
+        
+        template<typename ret>
+        class Signal0
+        {
+        public:
+                Signal0() : pCb( NULL ) { }
+                Signal0( _Slot0<ret> *pCb ) : pCb( pCb ) { }
+                Signal0( const Signal0<ret> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal0() { delete pCb; pCb = NULL; }
+
+                ret operator()()
+                {
+                        return (*pCb)();
+                }
+
+        private:
+                _Slot0<ret> *pCb;
+        };
+        
+        template<typename cls, typename ret>
+        Signal0<ret> slot( cls *pCls, ret (cls::*pFnc)() )
+        {
+                return Signal0<ret>(
+                        new __Slot0<cls, ret>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret>
+        Signal0<ret> slot( ret (*pFnc)() )
+        {
+                return Signal0<ret>(
+                        new __Slot0F<ret>( pFnc )
+                        );
+        }
+
+        //
+        // 1 Parameter
+        //
+
+        template<typename ret, typename p1t>
+        class _Slot1
+        {
+        public:
+                _Slot1() { }
+                virtual ~_Slot1() { }
+
+                virtual ret operator()( p1t p1 )=0;
+
+                virtual _Slot1<ret, p1t> *clone() const=0;
+        };
+
+        template<typename cls, typename ret, typename p1t>
+        class __Slot1 : public _Slot1<ret, p1t>
+        {
+        public:
+                __Slot1( cls *pCls, ret (cls::*pFnc)( p1t ) ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot1() { }
+
+                virtual ret operator()( p1t p1 )
+                {
+                        return (pCls->*pFnc)( p1 );
+                }
+                
+                virtual _Slot1<ret, p1t> *clone() const
+                {
+                        return new __Slot1<cls, ret, p1t>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)( p1t );
+        };
+
+        template<typename ret, typename p1t>
+        class __Slot1F : public _Slot1<ret, p1t>
+        {
+        public:
+                __Slot1F( ret (*pFnc)( p1t ) ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot1F() { }
+
+                virtual ret operator()( p1t p1 )
+                {
+                        return (*pFnc)( p1 );
+                }
+                
+                virtual _Slot1<ret, p1t> *clone() const
+                {
+                        return new __Slot1F<ret, p1t>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)( p1t p1 );
+        };
+        
+        template<typename ret, typename p1t>
+        class Signal1
+        {
+        public:
+                Signal1() : pCb( NULL ) { }
+                Signal1( _Slot1<ret, p1t> *pCb ) : pCb( pCb ) { }
+                Signal1( const Signal1<ret, p1t> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal1() { delete pCb; pCb = NULL; }
+
+                ret operator()( p1t p1 )
+                {
+                        return (*pCb)( p1 );
+                }
+
+        private:
+                _Slot1<ret, p1t> *pCb;
+        };
+        
+        template<typename cls, typename ret, typename p1t>
+        Signal1<ret, p1t> slot( cls *pCls, ret (cls::*pFnc)( p1t ) )
+        {
+                return Signal1<ret, p1t>(
+                        new __Slot1<cls, ret, p1t>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret, typename p1t>
+        Signal1<ret, p1t> slot( ret (*pFnc)( p1t ) )
+        {
+                return Signal1<ret, p1t>(
+                        new __Slot1F<ret, p1t>( pFnc )
+                        );
+        }
+
+        //
+        // 2 Parameters
+        //
+
+        template<typename ret, typename p1t, typename p2t>
+        class _Slot2
+        {
+        public:
+                _Slot2() { }
+                virtual ~_Slot2() { }
+
+                virtual ret operator()( p1t p1, p2t p2 )=0;
+
+                virtual _Slot2<ret, p1t, p2t> *clone() const=0;
+        };
+
+        template<typename cls, typename ret, typename p1t, typename p2t>
+        class __Slot2 : public _Slot2<ret, p1t, p2t>
+        {
+        public:
+                __Slot2( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot2() { }
+
+                virtual ret operator()( p1t p1, p2t p2 )
+                {
+                        return (pCls->*pFnc)( p1, p2 );
+                }
+                
+                virtual _Slot2<ret, p1t, p2t> *clone() const
+                {
+                        return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)( p1t, p2t );
+        };
+
+        template<typename ret, typename p1t, typename p2t>
+        class __Slot2F : public _Slot2<ret, p1t, p2t>
+        {
+        public:
+                __Slot2F( ret (*pFnc)( p1t, p2t ) ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot2F() { }
+
+                virtual ret operator()( p1t p1, p2t p2 )
+                {
+                        return (*pFnc)( p1, p2 );
+                }
+                
+                virtual _Slot2<ret, p1t, p2t> *clone() const
+                {
+                        return new __Slot2F<ret, p1t, p2t>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)( p1t, p2t );
+        };
+        
+        template<typename ret, typename p1t, typename p2t>
+        class Signal2
+        {
+        public:
+                Signal2() : pCb( NULL ) { }
+                Signal2( _Slot2<ret, p1t, p2t> *pCb ) : pCb( pCb ) { }
+                Signal2( const Signal2<ret, p1t, p2t> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal2() { delete pCb; pCb = NULL; }
+
+                ret operator()( p1t p1, p2t p2 )
+                {
+                        return (*pCb)( p1, p2 );
+                }
+
+        private:
+                _Slot2<ret, p1t, p2t> *pCb;
+        };
+        
+        template<typename cls, typename ret, typename p1t, typename p2t>
+        Signal2<ret, p1t, p2t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) )
+        {
+                return Signal2<ret, p1t, p2t>(
+                        new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret, typename p1t, typename p2t>
+        Signal2<ret, p1t, p2t> slot( ret (*pFnc)( p1t, p2t ) )
+        {
+                return Signal2<ret, p1t, p2t>(
+                        new __Slot2F<ret, p1t, p2t>( pFnc )
+                        );
+        }
+
+        //
+        // 3 Parameters
+        //
+
+        template<typename ret, typename p1t, typename p2t, typename p3t>
+        class _Slot3
+        {
+        public:
+                _Slot3() { }
+                virtual ~_Slot3() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0;
+
+                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0;
+        };
+
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
+        class __Slot3 : public _Slot3<ret, p1t, p2t, p3t>
+        {
+        public:
+                __Slot3( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot3() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3 )
+                {
+                        return (pCls->*pFnc)( p1, p2, p3 );
+                }
+                
+                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
+                {
+                        return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)( p1t, p2t, p3t );
+        };
+
+        template<typename ret, typename p1t, typename p2t, typename p3t>
+        class __Slot3F : public _Slot3<ret, p1t, p2t, p3t>
+        {
+        public:
+                __Slot3F( ret (*pFnc)( p1t, p2t, p3t ) ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot3F() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3 )
+                {
+                        return (*pFnc)( p1, p2, p3 );
+                }
+                
+                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
+                {
+                        return new __Slot3F<ret, p1t, p2t, p3t>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)( p1t, p2t, p3t );
+        };
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t>
+        class Signal3
+        {
+        public:
+                Signal3() : pCb( NULL ) { }
+                Signal3( _Slot3<ret, p1t, p2t, p3t> *pCb ) : pCb( pCb ) { }
+                Signal3( const Signal3<ret, p1t, p2t, p3t> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal3() { delete pCb; pCb = NULL; }
+
+                ret operator()( p1t p1, p2t p2, p3t p3 )
+                {
+                        return (*pCb)( p1, p2, p3 );
+                }
+
+        private:
+                _Slot3<ret, p1t, p2t, p3t> *pCb;
+        };
+        
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
+        Signal3<ret, p1t, p2t, p3t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) )
+        {
+                return Signal3<ret, p1t, p2t, p3t>(
+                        new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t>
+        Signal3<ret, p1t, p2t, p3t> slot( ret (*pFnc)( p1t, p2t, p3t ) )
+        {
+                return Signal3<ret, p1t, p2t, p3t>(
+                        new __Slot3F<ret, p1t, p2t, p3t>( pFnc )
+                        );
+        }
+
+        //
+        // 4 Parameters
+        //
+
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        class _Slot4
+        {
+        public:
+                _Slot4() { }
+                virtual ~_Slot4() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0;
+
+                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0;
+        };
+
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        class __Slot4 : public _Slot4<ret, p1t, p2t, p3t, p4t>
+        {
+        public:
+                __Slot4( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot4() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+                {
+                        return (pCls->*pFnc)( p1, p2, p3, p4 );
+                }
+                
+                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
+                {
+                        return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)( p1t, p2t, p3t, p4t );
+        };
+
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        class __Slot4F : public _Slot4<ret, p1t, p2t, p3t, p4t>
+        {
+        public:
+                __Slot4F( ret (*pFnc)( p1t, p2t, p3t, p4t ) ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot4F() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+                {
+                        return (*pFnc)( p1, p2, p3, p4 );
+                }
+                
+                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
+                {
+                        return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)( p1t, p2t, p3t, p4t );
+        };
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        class Signal4
+        {
+        public:
+                Signal4() : pCb( NULL ) { }
+                Signal4( _Slot4<ret, p1t, p2t, p3t, p4t> *pCb ) : pCb( pCb ) { }
+                Signal4( const Signal4<ret, p1t, p2t, p3t, p4t> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal4() { delete pCb; pCb = NULL; }
+
+                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+                {
+                        return (*pCb)( p1, p2, p3, p4 );
+                }
+
+        private:
+                _Slot4<ret, p1t, p2t, p3t, p4t> *pCb;
+        };
+        
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        Signal4<ret, p1t, p2t, p3t, p4t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) )
+        {
+                return Signal4<ret, p1t, p2t, p3t, p4t>(
+                        new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+        Signal4<ret, p1t, p2t, p3t, p4t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t ) )
+        {
+                return Signal4<ret, p1t, p2t, p3t, p4t>(
+                        new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc )
+                        );
+        }
+
+        //
+        // 5 Parameters
+        //
+
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        class _Slot5
+        {
+        public:
+                _Slot5() { }
+                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;
+        };
+
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        class __Slot5 : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
+        {
+        public:
+                __Slot5( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
+                        pCls( pCls ), pFnc( pFnc ) { }
+                virtual ~__Slot5() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+                {
+                        return (pCls->*pFnc)( p1, p2, p3, p4, p5 );
+                }
+                
+                virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
+                {
+                        return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc );
+                }
+        
+        private:
+                cls *pCls;
+                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t );
+        };
+
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        class __Slot5F : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
+        {
+        public:
+                __Slot5F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
+                        pFnc( pFnc ) { }
+                virtual ~__Slot5F() { }
+
+                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+                {
+                        return (*pFnc)( p1, p2, p3, p4, p5 );
+                }
+                
+                virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
+                {
+                        return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc );
+                }
+        
+        private:
+                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t );
+        };
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        class Signal5
+        {
+        public:
+                Signal5() : pCb( NULL ) { }
+                Signal5( _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb ) : pCb( pCb ) { }
+                Signal5( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rSrc ) :
+                        pCb( rSrc.pCb->clone() ) { }
+
+                virtual ~Signal5() { delete pCb; pCb = NULL; }
+
+                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+                {
+                        return (*pCb)( p1, p2, p3, p4, p5 );
+                }
+
+        private:
+                _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb;
+        };
+        
+        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
+        {
+                return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
+                        new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc )
+                        );
+        }
+        
+        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+        Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
+        {
+                return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
+                        new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc )
+                        );
+        }
+
+};
+
+#endif
diff --git a/src/tests/optparser.cpp b/src/tests/optparser.cpp
new file mode 100644
index 0000000..9168af8
--- /dev/null
+++ b/src/tests/optparser.cpp
@@ -0,0 +1,27 @@
+#include <bu/optparser.h>
+#include <bu/sio.h>
+using namespace Bu;
+
+class Opts : public Bu::OptParser
+{
+public:
+        Opts() :
+                iBob( 542 )
+        {
+                callback( this, &Opts::cb );
+        }
+
+        int cb( int argc, char *argv[] )
+        {
+                sio << "Hey, cb was called, here's a class var: " << iBob << sio.nl;
+                return 5;
+        }
+
+        int iBob;
+};
+
+int main( int argc, char *argv[] )
+{
+        Opts o;
+}
+
diff --git a/src/tests/signals.cpp b/src/tests/signals.cpp
new file mode 100644
index 0000000..b4b1363
--- /dev/null
+++ b/src/tests/signals.cpp
@@ -0,0 +1,87 @@
+#include <bu/signals.h>
+#include <bu/sio.h>
+
+using namespace Bu;
+
+class Thing
+{
+public:
+        Thing() :
+                iState( 82731 )
+        {
+        }
+
+        virtual ~Thing()
+        {
+        }
+
+        void fnc0()
+        {
+                sio << iState << ": void fnc0()" << sio.nl;
+        }
+        
+        void fnc1( int a )
+        {
+                sio << iState << ": void fnc1( " << a << " )" << sio.nl;
+        }
+        
+        void fnc2( int a, Bu::FString b )
+        {
+                sio << iState << ": void fnc2( " << a << ", \"" << b << "\" )" << sio.nl;
+        }
+        
+        void fnc3( int a, Bu::FString b, double c )
+        {
+                sio << iState << ": void fnc3( " << a << ", \"" << b << "\", " << c << " )" << sio.nl;
+        }
+        
+        void fnc4( int a, Bu::FString b, double c, char d )
+        {
+                sio << iState << ": void fnc4( " << a << ", \"" << b << "\", " << c << ", '" << d << "' )" << sio.nl;
+        }
+        
+        void fnc5( int a, Bu::FString b, double c, char d, long e )
+        {
+                sio << iState << ": void fnc5( " << a << ", \"" << b << "\", " << c << ", '" << d << "', " << e << " )" << sio.nl;
+        }
+
+private:
+        int iState;
+};
+
+void pfnc0()
+{
+        sio << "This doesn't have state, it's pfnc0()!" << sio.nl;
+}
+
+void callit( Signal0<void> sig )
+{
+        sig();
+}
+
+int main()
+{
+        Thing t;
+
+        Signal0<void> cb0( slot( &t, &Thing::fnc0 ) );
+        cb0();
+        
+        Signal1<void, int> cb1( slot( &t, &Thing::fnc1 ) );
+        cb1( 5 );
+        
+        Signal2<void, int, Bu::FString> cb2( slot( &t, &Thing::fnc2 ) );
+        cb2( 5, "Hi there" );
+        
+        Signal3<void, int, Bu::FString, double> cb3( slot( &t, &Thing::fnc3 ) );
+        cb3( 5, "Hi there", 12.85 );
+        
+        Signal4<void, int, Bu::FString, double, char> cb4( slot( &t, &Thing::fnc4 ) );
+        cb4( 5, "Hi there", 12.85, 'z' );
+        
+        Signal5<void, int, Bu::FString, double, char, long> cb5( slot( &t, &Thing::fnc5 ) );
+        cb5( 5, "Hi there", 12.85, 'z', 849 );
+
+//      Signal1<int, int> cb1( slot( &t, &Thing::fnc1 ) );
+//      sio << "Result: " << cb1( 5 ) << sio.nl;
+}
+
diff --git a/src/tests/socket.cpp b/src/tests/socket.cpp
new file mode 100644
index 0000000..1cf63e4
--- /dev/null
+++ b/src/tests/socket.cpp
@@ -0,0 +1,66 @@
+#include <bu/socket.h>
+#include <bu/sio.h>
+
+#include <sys/time.h>
+#include <time.h>
+
+using namespace Bu;
+
+bool isUp()
+{
+        try
+        {
+                Socket s("xagasoft.com", 9898, 1 );
+
+                char buf[5];
+                buf[s.read(buf, 2, 1, 0)] = '\0';
+                
+                if( !strcmp( buf, "hi" ) )
+                        return true;
+                else
+                        return false;
+        }
+        catch(...)
+        {
+                return false;
+        }
+}
+
+int main()
+{
+        uint32_t uUp = 0;
+        uint32_t uDown = 0;
+        uint32_t uTotal = 0;
+        struct timeval tv;
+
+        for(;;)
+        {
+                gettimeofday( &tv, NULL );
+                time_t goal = ((tv.tv_sec/5)+1)*5;
+                tv.tv_sec = goal-tv.tv_sec;
+                tv.tv_usec = 0-tv.tv_usec;
+                if( tv.tv_usec < 0 )
+                {
+                        tv.tv_sec--;
+                        tv.tv_usec = 1000000+tv.tv_usec;
+                }
+                select( 0, NULL, NULL, NULL, &tv );
+                gettimeofday( &tv, NULL );
+                if( isUp() )
+                {
+                        uUp++;
+                        sio << "status: up   ";
+                }
+                else
+                {
+                        uDown++;
+                        sio << "status: down ";
+                }
+                uTotal++;
+
+                sio << "(up=" << (uUp*5) << "s, down=" << (uDown*5) << ") up for "
+                        << uUp*100/uTotal << "% of " << uTotal*5 << "s" << sio.nl
+                        << sio.flush;
+        }
+}
+