The new signal/slots system is in place, and works from 0-5 parameters right

now, I'll probably add more later on...

I've also started on the replacement for ParamProc, OptParser.  It should do
everything that ParamProc did, only with less code, and much better.

7 files changed, 930 insertions, 0 deletions

diff --git a/buildm3.conf b/buildm3.conf
new file mode 100644
index 0000000..ccc7131
--- /dev/null
+++ b/buildm3.conf
@@ -0,0 +1,68 @@
+# vim: syntax=build
+
+set CXXFLAGS += "-ggdb -W -Wall";
+
+action "default"
+{
+        build: [targets("header-links"), "libbu++.a"];
+}
+
+action "pkg"
+{
+        build: targets("pkg");
+}
+
+target files("src/*.h").replace("src/", "bu/")
+{
+        tag "header-links";
+        display "symlink";
+        input OUTPUT.replace("bu/","src/");
+        profile "build"
+        {
+                execute("ln -s ../${INPUT} ${OUTPUT}");
+        }
+}
+
+target "libbu++.a"
+{
+        input files("src/*.cpp");
+        rule "lib";
+        set CXXFLAGS += "-I. -fPIC";
+}
+
+target "libbu++-r$(svnversion "-n").tar.bz2"
+{
+        input [
+                "LICENSE",
+                "build.conf",
+                "Doxyfile",
+                "buildm3.conf",
+                "support/vim/syntax/taf.vim",
+                "support/vim/ftdetect/taf.vim",
+                "support/vim/ftplugin/taf.vim",
+                files("*.sh"),
+                files("src/*.cpp"),
+                files("src/*.h"),
+                files("src/tests/*.cpp"),
+                files("src/tests*.h"),
+                files("src/tools/*.cpp"),
+                files("src/tools/*.h"),
+                files("src/unit/*.unit"),
+                files("src/doxy/*.dox")
+                ];
+        rule "tarball";
+        tag "pkg";
+}
+
+rule "tarball"
+{
+        input matches("LICENSE", "*.cpp", "*.h", "*.conf", "Doxyfile", "*.vim",
+                "*.sh");
+        profile "build"
+        {
+                set OUTDIR = OUTPUT.replace(".tar.bz2","");
+                execute("tar --transform=\"s@^@${OUTDIR}/@\" -c ${INPUT} |"
+                        " bzip2 -9 > ${OUTPUT}");
+        }
+}
+
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;
+        }
+}
+