Interesting tweak to the variant and optparser classes. In the Variant, it

would always fail if a const char * was passed in, it now converts these
silently to Bu::FStrings, good to know...

Also, the OptParser now uses a Variant for overrides, meaning it doesn't have
to do extra parsing, and the amount of code you have to write may be
significantly reduced.  Pretty sweet, overall.  There is one downside.  For the
moment if you use a non-standard type or object as the target of a parameter
it always needs to have a formatter >> operator defined, even if you override
and the formatter >> operator is never called.  Hopefully we can get around
this in the future.

Also, it looks like it should be relatively trivial to create conversion
functions for the variant, they'll just be global template functions that
take two parameters, source type and target type.  Should be good times.

1 files changed, 23 insertions, 5 deletions

diff --git a/src/optparser.h b/src/optparser.h
index 2936a4b..7ec69e5 100644
--- a/src/optparser.h
+++ b/src/optparser.h
@@ -15,6 +15,7 @@
 #include "bu/array.h"
 #include "bu/membuf.h"
 #include "bu/formatter.h"
+#include "bu/variant.h"
 
 namespace Bu
 {
@@ -40,7 +41,8 @@ namespace Bu
                         _ValueProxy();
                         virtual ~_ValueProxy();
 
-                        virtual void setValue( const Bu::FString & )=0;
+                        virtual void setValueFromStr( const Bu::FString & )=0;
+                        virtual void setValue( const Bu::Variant &vVar )=0;
                         virtual _ValueProxy *clone()=0;
                 };
 
@@ -57,12 +59,28 @@ namespace Bu
                         {
                         }
 
-                        virtual void setValue( const Bu::FString &sVal )
+                        virtual void setValueFromStr( const Bu::FString &sVal )
                         {
                                 Bu::MemBuf mb( sVal );
                                 Bu::Formatter f( mb );
                                 f >> v;
                         }
+
+                        virtual void setValue( const Bu::Variant &vVar )
+                        {
+                                if( vVar.getType() == typeid(ptype) )
+                                {
+                                        v = vVar.get<ptype>();
+                                }
+                                else if( vVar.getType() == typeid(Bu::FString) )
+                                {
+                                        setValueFromStr( vVar.get<Bu::FString>() );
+                                }
+                                else
+                                {
+                                        setValueFromStr( vVar.toString() );
+                                }
+                        }
                         
                         virtual _ValueProxy *clone()
                         {
@@ -87,7 +105,7 @@ namespace Bu
                         Bu::FString sHelp;
                         OptionSignal sUsed;
                         _ValueProxy *pProxy;
-                        Bu::FString sOverride;
+                        Bu::Variant sOverride;
                         Bu::FString sHelpDefault;
                 };
         
@@ -162,9 +180,9 @@ namespace Bu
                         addOption( sUsed, cOpt, "", sHelp );
                 }
 
-                void setOverride( char cOpt, const Bu::FString &sOverride );
+                void setOverride( char cOpt, const Bu::Variant &sOverride );
                 void setOverride( const Bu::FString &sOpt,
-                                const Bu::FString &sOverride );
+                                const Bu::Variant &sOverride );
 
                 void setHelpDefault( const Bu::FString &sOpt, const Bu::FString &sTxt );