Wow, cool, Bu::Formatter can read all the basic types now, (int, float, bool,

char, etc.) and OptParser totally works.  I have one last change to make to it,
which is using the return value of signal type options to determine weather or
not the option took a parameter at all, especially in the case of short options.

7 files changed, 340 insertions, 32 deletions

diff --git a/src/formatter.cpp b/src/formatter.cpp
index 5ab1b3f..14f70ed 100644
--- a/src/formatter.cpp
+++ b/src/formatter.cpp
@@ -111,6 +111,11 @@ void Bu::Formatter::writeAligned( const char *sStr, int iLen )
         usedFormat();
 }
 
+void Bu::Formatter::read( void *sStr, int iLen )
+{
+        rStream.read( sStr, iLen );
+}
+
 Bu::FString Bu::Formatter::readToken()
 {
         Bu::FString sRet;
@@ -362,3 +367,101 @@ Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::FString &sStr )
         return f;
 }
 
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed short &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned short &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed int &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned int &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long long &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long long &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, float &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, double &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, long double &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, bool &b )
+{
+        Bu::FString sStr = f.readToken();
+        if( !sStr )
+                return f;
+        char c = *sStr.begin();
+        if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
+                b = true;
+        else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
+                b = false;
+
+        return f;
+}
+
diff --git a/src/formatter.h b/src/formatter.h
index aec5c5d..3f51e8e 100644
--- a/src/formatter.h
+++ b/src/formatter.h
@@ -103,6 +103,7 @@ namespace Bu
                 void writeAligned( const Bu::FString &sStr );
                 void writeAligned( const char *sStr, int iLen );
 
+                void read( void *sStr, int iLen );
                 Bu::FString readToken();
 
                 void incIndent();
@@ -199,6 +200,63 @@ namespace Bu
                         writeAligned( fTmp );
                         usedFormat();
                 }
+                
+                template<typename type>
+                void iparse( type &i, const Bu::FString &sBuf )
+                {
+                        if( !sBuf )
+                                return;
+                        if( sBuf[0] != '+' && sBuf[0] != '-' &&
+                                (sBuf[0] < '0' && sBuf[0] > '9') )
+                                return;
+                        int j = 1;
+                        int iMax = sBuf.getSize();
+                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+                        i = 0;
+                        type iPos = 1;
+                        for(j--; j >= 0; j-- )
+                        {
+                                if( sBuf[j] == '+' || sBuf[j] == '-' )
+                                        continue;
+                                i += (sBuf[j]-'0')*iPos;
+                                iPos *= fLast.uRadix;
+                        }
+                        if( sBuf[0] == '-' )
+                                i = -i;
+
+                        usedFormat();
+                }
+                
+                template<typename type>
+                void uparse( type &i, const Bu::FString &sBuf )
+                {
+                        if( !sBuf )
+                                return;
+                        if( sBuf[0] != '+' &&
+                                (sBuf[0] < '0' && sBuf[0] > '9') )
+                                return;
+                        int j = 1;
+                        int iMax = sBuf.getSize();
+                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+                        i = 0;
+                        type iPos = 1;
+                        for(j--; j >= 0; j-- )
+                        {
+                                if( sBuf[j] == '+' )
+                                        continue;
+                                i += (sBuf[j]-'0')*iPos;
+                                iPos *= fLast.uRadix;
+                        }
+
+                        usedFormat();
+                }
+                
+                template<typename type>
+                void fparse( type &f, const Bu::FString &sBuf )
+                {
+                        sscanf( sBuf.getStr(), "%f", &f );
+                        usedFormat();
+                }
 
                 enum Special
                 {
@@ -243,6 +301,21 @@ namespace Bu
         Formatter &operator<<( Formatter &f, bool b );
 
         Formatter &operator>>( Formatter &f, Bu::FString &sStr );
+        Formatter &operator>>( Formatter &f, signed char &c );
+        Formatter &operator>>( Formatter &f, char &c );
+        Formatter &operator>>( Formatter &f, unsigned char &c );
+        Formatter &operator>>( Formatter &f, signed short &i );
+        Formatter &operator>>( Formatter &f, unsigned short &i );
+        Formatter &operator>>( Formatter &f, signed int &i );
+        Formatter &operator>>( Formatter &f, unsigned int &i );
+        Formatter &operator>>( Formatter &f, signed long &i );
+        Formatter &operator>>( Formatter &f, unsigned long &i );
+        Formatter &operator>>( Formatter &f, signed long long &i );
+        Formatter &operator>>( Formatter &f, unsigned long long &i );
+        Formatter &operator>>( Formatter &f, float &flt );
+        Formatter &operator>>( Formatter &f, double &flt );
+        Formatter &operator>>( Formatter &f, long double &flt );
+        Formatter &operator>>( Formatter &f, bool &b );
 
         template<typename type>
         Formatter &operator<<( Formatter &f, const type *p )
diff --git a/src/optparser.cpp b/src/optparser.cpp
index 2a8e64b..d656e12 100644
--- a/src/optparser.cpp
+++ b/src/optparser.cpp
@@ -106,6 +106,14 @@ void Bu::OptParser::parse( int argc, char **argv )
                                                                         );
                                                                 break;
                                                         }
+                                                        else if( argv[j+1] )
+                                                        {
+                                                                pOpt->pProxy->setValue(
+                                                                        argv[j+1]
+                                                                        );
+                                                                j++;
+                                                                break;
+                                                        }
                                                 }
                                         }
                                         else
@@ -135,6 +143,16 @@ void Bu::OptParser::addOption( const Option &opt )
                 hlOption.insert( opt.sOpt, &lOption.last() );
 }
 
+void Bu::OptParser::setOverride( char cOpt, const Bu::FString &sOverride )
+{
+        hsOption.get( cOpt )->sOverride = sOverride;
+}
+
+void Bu::OptParser::setOverride( const Bu::FString &sOpt, const Bu::FString &sOverride )
+{
+        hlOption.get( sOpt )->sOverride = sOverride;
+}
+
 void Bu::OptParser::addHelpOption( char c, const Bu::FString &s, const Bu::FString &sHelp )
 {
         Option o;
@@ -146,7 +164,19 @@ void Bu::OptParser::addHelpOption( char c, const Bu::FString &s, const Bu::FStri
         addOption( o );
 }
 
-int Bu::OptParser::optHelp( StrArray aParams )
+void Bu::OptParser::addHelpBanner( const Bu::FString &sText, bool bFormatted )
+{
+        Banner b;
+        b.sText = sText;
+        b.bFormatted = bFormatted;
+        if( lOption.getSize() > 0 )
+        {
+                for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
+        }
+        lBanner.append( b );
+}
+
+int Bu::OptParser::optHelp( StrArray /*aParams*/ )
 {
         bool bHasShort = false;
         int iMaxWidth = 0;
@@ -166,6 +196,19 @@ int Bu::OptParser::optHelp( StrArray aParams )
                 iIndent += 4;
         if( iMaxWidth > 0 )
                 iIndent += 4 + iMaxWidth;
+
+        BannerList::iterator iBanner;
+        for( iBanner = lBanner.begin(); iBanner; iBanner++ )
+        {
+                if( (*iBanner).iAfter )
+                        break;
+
+                if( (*iBanner).bFormatted )
+                        sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+                else
+                        sio << (*iBanner).sText;
+                sio << sio.nl;
+        }
         for( OptionList::iterator i = lOption.begin(); i; i++ )
         {
                 sio << "    ";
@@ -191,6 +234,18 @@ int Bu::OptParser::optHelp( StrArray aParams )
                 }
                 sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
                 sio << sio.nl;
+        
+                for( ; iBanner; iBanner++ )
+                {
+                        if( (*iBanner).iAfter != i )
+                                break;
+                        
+                        if( (*iBanner).bFormatted )
+                                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+                        else
+                                sio << (*iBanner).sText;
+                        sio << sio.nl;
+                }
         }
         exit( 0 );
         return 0;
diff --git a/src/optparser.h b/src/optparser.h
index acfb35d..425bc90 100644
--- a/src/optparser.h
+++ b/src/optparser.h
@@ -14,7 +14,7 @@ namespace Bu
         typedef Bu::Array<Bu::FString> StrArray;
         class OptParser
         {
-        public:
+        private:
                 class _ValueProxy
                 {
                 public:
@@ -54,6 +54,7 @@ namespace Bu
                         ptype &v;
                 };
 
+        public:
                 typedef Signal1<int, StrArray> OptionSignal;
                 class Option
                 {
@@ -70,6 +71,21 @@ namespace Bu
                         _ValueProxy *pProxy;
                         Bu::FString sOverride;
                 };
+        
+        private:
+                typedef Bu::List<Option> OptionList;
+                typedef Bu::Hash<char, Option *> ShortOptionHash;
+                typedef Bu::Hash<Bu::FString, Option *> LongOptionHash;
+                
+                class Banner
+                {
+                public:
+                        Bu::FString sText;
+                        bool bFormatted;
+                        OptionList::const_iterator iAfter;
+                };
+
+                typedef Bu::List<Banner> BannerList;
 
         public:
                 OptParser();
@@ -80,8 +96,8 @@ namespace Bu
                 void addOption( const Option &opt );
                 
                 template<typename vtype>
-                void addOption( char cOpt, const Bu::FString &sOpt, vtype &var,
-                                const Bu::FString &sHelp="", const Bu::FString &sOverride="" )
+                void addOption( vtype &var, char cOpt, const Bu::FString &sOpt,
+                                const Bu::FString &sHelp )
                 {
                         Option o;
                         o.cOpt = cOpt;
@@ -89,24 +105,64 @@ namespace Bu
                         o.pProxy = new ValueProxy<vtype>( var );
                         o.bShortHasParams = true;
                         o.sHelp = sHelp;
-                        o.sOverride = sOverride;
                         addOption( o );
                 }
                 
-                void addHelpOption( char c, const Bu::FString &s, const Bu::FString &sHelp );
+                template<typename vtype>
+                void addOption( vtype &var, const Bu::FString &sOpt,
+                                const Bu::FString &sHelp )
+                {
+                        addOption( var, '\0', sOpt, sHelp );
+                }
+                
+                template<typename vtype>
+                void addOption( vtype &var, char cOpt, const Bu::FString &sHelp )
+                {
+                        addOption( var, cOpt, "", sHelp );
+                }
+
+                void addOption( OptionSignal sUsed, char cOpt, const Bu::FString &sOpt,
+                                const Bu::FString &sHelp )
+                {
+                        Option o;
+                        o.cOpt = cOpt;
+                        o.sOpt = sOpt;
+                        o.sUsed = sUsed;
+                        o.sHelp = sHelp;
+                        addOption( o );
+                }
+                
+                void addOption( OptionSignal sUsed, const Bu::FString &sOpt,
+                                const Bu::FString &sHelp )
+                {
+                        addOption( sUsed, '\0', sOpt, sHelp );
+                }
+                
+                void addOption( OptionSignal sUsed, char cOpt,
+                                const Bu::FString &sHelp )
+                {
+                        addOption( sUsed, cOpt, "", sHelp );
+                }
+
+                void setOverride( char cOpt, const Bu::FString &sOverride );
+                void setOverride( const Bu::FString &sOpt,
+                                const Bu::FString &sOverride );
+                
+//              void addOption( char cOpt, const Bu::FString &sOpt, 
+                
+                void addHelpOption( char c='h', const Bu::FString &s="help",
+                                const Bu::FString &sHelp="This help." );
+                void addHelpBanner( const Bu::FString &sText, bool bFormatted=true );
 
                 int optHelp( StrArray aParams );
 
         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;
+                BannerList lBanner;
         };
 };
 
diff --git a/src/stdstream.cpp b/src/stdstream.cpp
index 05b8ee7..6f9f052 100644
--- a/src/stdstream.cpp
+++ b/src/stdstream.cpp
@@ -5,6 +5,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
+#include <stdio.h>
 #include "bu/stdstream.h"
 
 Bu::StdStream::StdStream()
diff --git a/src/stdstream.h b/src/stdstream.h
index 1bde088..6de1e8c 100644
--- a/src/stdstream.h
+++ b/src/stdstream.h
@@ -9,7 +9,6 @@
 #define BU_STD_STREAM_H
 
 #include <stdint.h>
-#include <stdio.h>
 #include "stream.h"
 
 namespace Bu
diff --git a/src/tests/optparser.cpp b/src/tests/optparser.cpp
index 5cf82bd..f5df7ed 100644
--- a/src/tests/optparser.cpp
+++ b/src/tests/optparser.cpp
@@ -8,35 +8,54 @@ public:
         Opts() :
                 iBob( 542 )
         {
-                Option o;
-                o.sUsed = slot( this, &Opts::cb );
-                o.cOpt = 'x';
-                o.sOpt = "things";
-                o.bShortHasParams = true;
-                o.sHelp = "This is the first test parameter.  It calls a function, and takes parameters.";
-                addOption( o );
-                
-                Option o2;
-                o2.sUsed = slot( this, &Opts::cb );
-                o2.cOpt = 'y';
-                o2.sOpt = "stuff";
-                o2.bShortHasParams = false;
-                o2.sHelp = "This is the second test parameter.  It does not take parameters.  However, I do want to make this part much longer to see how it looks when you add way too much text to one of these things.  It can't really be that bad, right?";
-                addOption( o2 );
-
-                addOption( 's', "str", sVar, "Set a variable, see what it does.", "bob!");
+                addHelpBanner("optparser - Test some option things...");
+
+                addHelpBanner("\nThis section represents options that actually have "
+                        "callbacks, or in the case of the new system, signals/slots.  They "
+                        "all take parameters, but if they return 0 then it will be as "
+                        "though they hadn't and the next thing will be processed normally.",
+                        true
+                        );
+                addOption( slot( this, &Opts::yesparam ), 'x', "things",
+                        "This is the first test parameter.  It calls a function, and "
+                        "takes a parameter."
+                        );
+                addOption( slot( this, &Opts::noparam ), 'y', "stuff",
+                        "This is the second test parameter.  It does not take "
+                        "parameters.  However, I do want to make this part much longer to "
+                        "see how it looks when you add way too much text to one of these "
+                        "things.  It can't really be that bad, right?"
+                        );
+
+                addHelpBanner("\nThis section represents options with no callback or "
+                        "signal, but do have a variable to update.  They use the Formatter "
+                        "system and therefore it's very, very flexible.  Any data type "
+                        "you can read with a formatter you can set via parameter.",
+                        true
+                        );
+                addOption( sVar, 's', "str", "Set a variable, see what it does.");
+                addOption( iBob, "bob", "Change iBob to wahtever you want.");
+                addOption( dBob, 'd', "Change dBob to wahtever you want.");
+
+                setOverride("str", "Bob!");
         
-                addHelpOption('h', "help", "This help.");
+                addHelpOption();
         }
 
-        int cb( StrArray aParams )
+        int yesparam( StrArray aParams )
         {
-                sio << "Hey, cb was called, here's a class var: " << iBob << sio.nl;
-                sio << "argv[] = " << aParams << sio.nl;
+                sio << " - yesparam" << aParams << sio.nl;
                 return 1;
         }
 
+        int noparam( StrArray aParams )
+        {
+                sio << " - noparam" << aParams << sio.nl;
+                return 0;
+        }
+
         int iBob;
+        float dBob;
         Bu::FString sVar;
 };
 
@@ -47,5 +66,7 @@ int main( int argc, char *argv[] )
         o.parse( argc, argv );
 
         sio << "sVar = \"" << o.sVar << "\"" << sio.nl;
+        sio << "iBob = " << o.iBob << sio.nl;
+        sio << "dBob = " << o.dBob << sio.nl;
 }