From 6886ca3542907f498eb6c30aa76474f15e7afc39 Mon Sep 17 00:00:00 2001
From: randomdan <randomdan@localhost>
Date: Fri, 29 Mar 2013 21:37:22 +0000
Subject: Split variable and variabletype code into separate files Use
 variabletype in populating options data Add code for guessing the type of
 some input data

---
 project2/cgi/cgiEnvironment.cpp         |   2 +-
 project2/cgi/cgiEnvironment.h           |   2 +-
 project2/common/options.cpp             |   9 +-
 project2/common/options.h               |  36 +++--
 project2/common/pch.hpp                 |   1 +
 project2/common/variableConvert.cpp     |   4 +-
 project2/common/variableType.cpp        | 258 ++++++++++++++++++++++++++++++++
 project2/common/variableType.h          | 105 +++++++++++++
 project2/common/variables.cpp           | 244 ------------------------------
 project2/common/variables.h             |  97 +-----------
 project2/common/variables/config.cpp    |   4 +-
 project2/console/consoleEnvironment.cpp |   2 +-
 project2/streams/streamNvpRows.cpp      |   3 +-
 13 files changed, 401 insertions(+), 366 deletions(-)
 create mode 100644 project2/common/variableType.cpp
 create mode 100644 project2/common/variableType.h

diff --git a/project2/cgi/cgiEnvironment.cpp b/project2/cgi/cgiEnvironment.cpp
index 6462f5c..048f7d7 100644
--- a/project2/cgi/cgiEnvironment.cpp
+++ b/project2/cgi/cgiEnvironment.cpp
@@ -193,7 +193,7 @@ HostnamePlatformIdentifier::paramRequired() const
 }
 
 void
-HostnamePlatformIdentifier::consume(const Glib::ustring & p, const Glib::ustring & r) const
+HostnamePlatformIdentifier::consume(const Glib::ustring & p, const VariableType & r) const
 {
 	if (!platform && Glib::Regex::create(r, Glib::REGEX_CASELESS | Glib::REGEX_DOTALL)->match(Environment::getCurrent()->getServerName())) {
 		platform = new Glib::ustring(p);
diff --git a/project2/cgi/cgiEnvironment.h b/project2/cgi/cgiEnvironment.h
index 176ca8d..c09f5a9 100644
--- a/project2/cgi/cgiEnvironment.h
+++ b/project2/cgi/cgiEnvironment.h
@@ -21,7 +21,7 @@ class HostnamePlatformIdentifier : public Options::Target {
 		virtual ~HostnamePlatformIdentifier();
 		void reset() const;
 		bool paramRequired() const;
-		void consume(const Glib::ustring &, const Glib::ustring &) const;
+		void consume(const Glib::ustring &, const VariableType &) const;
 		const Glib::ustring & derivedPlatform() const;
 	private:
 		mutable Glib::ustring * platform;
diff --git a/project2/common/options.cpp b/project2/common/options.cpp
index 94ae861..60fd7cd 100644
--- a/project2/common/options.cpp
+++ b/project2/common/options.cpp
@@ -11,7 +11,7 @@ class NamedOption : public Options::Option {
 			desc(d)
 		{
 		}
-		void consume(const Glib::ustring & n, const Glib::ustring & p, const Glib::ustring & v) const {
+		void consume(const Glib::ustring & n, const Glib::ustring & p, const VariableType & v) const {
 			if (n == id) {
 				target->consume(p, v);
 			}
@@ -44,7 +44,7 @@ class OptionAlias : public Options::Option {
 			target(t)
 		{
 		}
-		void consume(const Glib::ustring & a, const Glib::ustring & p, const Glib::ustring & v) const {
+		void consume(const Glib::ustring & a, const Glib::ustring & p, const VariableType & v) const {
 			if (a == alias) {
 				target->target->consume(p, v);
 			}
@@ -108,12 +108,13 @@ Options::reset() const
 }
 
 void
-Options::consume(const Glib::ustring & n, const Glib::ustring & p, const Glib::ustring & v) const
+Options::consume(const Glib::ustring & n, const Glib::ustring & p, const VariableType & v) const
 {
 	BOOST_FOREACH(const OptionPtr & o, options) {
 		o->consume(n, p, v);
 	}
 }
+
 const Options::Option *
 Options::find(const Glib::ustring & n) const {
 	BOOST_FOREACH(const OptionPtr & o, options) {
@@ -130,7 +131,7 @@ Options::InstanceTarget::InstanceTarget() :
 }
 
 void
-Options::InstanceTarget::consume(const Glib::ustring & p, const Glib::ustring & v) const
+Options::InstanceTarget::consume(const Glib::ustring & p, const VariableType & v) const
 {
 	if (ts != Platform && p.empty()) {
 		assign(v);
diff --git a/project2/common/options.h b/project2/common/options.h
index 93c6aa5..8b9e9a0 100644
--- a/project2/common/options.h
+++ b/project2/common/options.h
@@ -7,6 +7,7 @@
 #include <list>
 #include <boost/lexical_cast.hpp>
 #include <boost/utility/enable_if.hpp>
+#include "variableType.h"
 
 #if !__GNUC_PREREQ(4,7)
 //      If  gcc_version >= 4.0
@@ -41,7 +42,7 @@ class Options {
 			public:
 				virtual void reset() const = 0;
 				virtual bool paramRequired() const = 0;
-				virtual void consume(const Glib::ustring & platform, const Glib::ustring & value) const = 0;
+				virtual void consume(const Glib::ustring & platform, const VariableType & value) const = 0;
 		};
 		typedef boost::intrusive_ptr<Target> TargetPtr;
 
@@ -51,9 +52,9 @@ class Options {
 				bool paramRequired() const {
 					return true;
 				}
-				void consume(const Glib::ustring & platform, const Glib::ustring & value) const;
+				void consume(const Glib::ustring & platform, const VariableType & value) const;
 			protected:
-				virtual void assign(const Glib::ustring & value) const = 0;
+				virtual void assign(const VariableType & value) const = 0;
 				mutable TargetState ts;
 		};
 
@@ -71,18 +72,27 @@ class Options {
 					ts = Default;
 					*target = defValue;
 				}
-				void assign(const Glib::ustring & value) const {
+				void assign(const VariableType & value) const {
 					doAssign(value);
 				}
 			protected:
 				T * target;
 			private:
 				template <typename dummy = int>
-				void doAssign(const Glib::ustring & value, typename boost::disable_if<std::is_assignable<T, Glib::ustring>, dummy>::type = 0) const {
-					*target = boost::lexical_cast<T>(value);
+				void doAssign(const VariableType & value,
+						typename boost::disable_if<std::is_assignable<T, VariableType>, dummy>::type = 0,
+						typename boost::disable_if<std::is_convertible<VariableType, T>, dummy>::type = 0) const {
+					*target = boost::lexical_cast<T>(value.as<Glib::ustring>());
 				}
 				template <typename dummy = int>
-				void doAssign(const Glib::ustring & value, typename boost::enable_if<std::is_assignable<T, Glib::ustring>, dummy>::type = 0) const {
+				void doAssign(const VariableType & value,
+						typename boost::enable_if<std::is_convertible<VariableType, T>, dummy>::type = 0) const {
+					*target = value.as<T>();
+				}
+				template <typename dummy = int>
+				void doAssign(const VariableType & value,
+						typename boost::disable_if<std::is_convertible<VariableType, T>, dummy>::type = 0,
+						typename boost::enable_if<std::is_assignable<T, VariableType>, dummy>::type = 0) const {
 					*target = value;
 				}
 				D defValue;
@@ -98,18 +108,18 @@ class Options {
 					ts = Default;
 					target->clear();
 				}
-				void assign(const Glib::ustring & value) const {
+				void assign(const VariableType & value) const {
 					doAssign(value);
 				}
 			protected:
 				VofT * target;
 			private:
 				template <typename dummy = int>
-				void doAssign(const Glib::ustring & value, typename boost::disable_if<std::is_constructible<T, Glib::ustring>, dummy>::type = 0) const {
-					target->push_back(boost::lexical_cast<T>(value));
+				void doAssign(const VariableType & value, typename boost::disable_if<std::is_constructible<T, VariableType>, dummy>::type = 0) const {
+					target->push_back(boost::lexical_cast<T>(value.as<Glib::ustring>()));
 				}
 				template <typename dummy = int>
-				void doAssign(const Glib::ustring & value, typename boost::enable_if<std::is_constructible<T, Glib::ustring>, dummy>::type = 0) const {
+				void doAssign(const VariableType & value, typename boost::enable_if<std::is_constructible<T, VariableType>, dummy>::type = 0) const {
 					target->push_back(T(value));
 				}
 		};
@@ -121,7 +131,7 @@ class Options {
 				virtual Glib::ustring name() const = 0;
 				virtual Glib::ustring description() const = 0;
 				virtual bool accepts(const Glib::ustring & name) const = 0;
-				virtual void consume(const Glib::ustring & name, const Glib::ustring & platform, const Glib::ustring & value) const = 0;
+				virtual void consume(const Glib::ustring & name, const Glib::ustring & platform, const VariableType & value) const = 0;
 		};
 		typedef boost::intrusive_ptr<Option> OptionPtr;
 
@@ -147,7 +157,7 @@ class Options {
 		}
 
 		void reset() const;
-		void consume(const Glib::ustring & name, const Glib::ustring & platform, const Glib::ustring & value) const;
+		void consume(const Glib::ustring & name, const Glib::ustring & platform, const VariableType & value) const;
 		const Option * find(const Glib::ustring & name) const;
 
 		const Glib::ustring name;
diff --git a/project2/common/pch.hpp b/project2/common/pch.hpp
index 4150755..da12580 100644
--- a/project2/common/pch.hpp
+++ b/project2/common/pch.hpp
@@ -26,6 +26,7 @@
 #include "scriptStorage.h"
 #include "scriptLoader.h"
 #include "variables.h"
+#include "variableType.h"
 #include "sourceObject.h"
 #include "scripts.h"
 
diff --git a/project2/common/variableConvert.cpp b/project2/common/variableConvert.cpp
index 6237c26..d0363f5 100644
--- a/project2/common/variableConvert.cpp
+++ b/project2/common/variableConvert.cpp
@@ -151,8 +151,8 @@ class ConvertVisitorBool : public boost::static_visitor<bool> {
 	private:
 		static bool fromStr(const Glib::ustring & s) {
 			const char * str = s.c_str();
-			if (strcasecmp(str, "true") == 0 || strcasecmp(str, "yes") == 0 || strcasecmp(str, "on") == 0) return true;
-			if (strcasecmp(str, "false") == 0 || strcasecmp(str, "no") == 0 || strcasecmp(str, "off") == 0) return false;
+			if (strcasecmp(str, "true") == 0 || strcasecmp(str, "yes") == 0 || strcasecmp(str, "on") == 0 || strcasecmp(str, "1") == 0) return true;
+			if (strcasecmp(str, "false") == 0 || strcasecmp(str, "no") == 0 || strcasecmp(str, "off") == 0 || strcasecmp(str, "0") == 0) return false;
 			throw InvalidConversionTo("bool", s);
 		}
 		const VariableType * var;
diff --git a/project2/common/variableType.cpp b/project2/common/variableType.cpp
new file mode 100644
index 0000000..710296a
--- /dev/null
+++ b/project2/common/variableType.cpp
@@ -0,0 +1,258 @@
+#include <pch.hpp>
+#include "variableType.h"
+#include "logger.h"
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+
+SimpleMessageException(UnknownVariableType);
+
+Boolean::Boolean(bool v) : value(v)
+{
+}
+
+bool
+Boolean::operator<(const Boolean & b) const
+{
+	return ((this->value == false) && (b.value == true));
+}
+
+Boolean::operator bool() const
+{
+	return this->value;
+}
+
+std::basic_ostream<char> &
+operator<<(std::basic_ostream<char> & os, const Boolean & b)
+{
+	os << (b.value ? "true" : "false");
+	return os;
+}
+
+std::basic_ostream<unsigned char> &
+operator<<(std::basic_ostream<unsigned char> & os, const Boolean & b)
+{
+	os << (b.value ? "true" : "false");
+	return os;
+}
+
+VT_typeID
+VariableType::getTypeFromName(const std::string & src)
+{
+	if (src.empty()) return String;
+	if (src == "string") return String;
+	if (src == "bool") return Bool;
+	if (src == "int") return Int;
+	if (src == "float") return Float;
+	if (src == "datetime") return DateTime;
+	if (src == "null") return Nul;
+	throw UnknownVariableType(src);
+}
+
+VariableType
+VariableType::make(const Glib::ustring & src, const VT_typeID format)
+{
+	VariableType vt(src);
+	vt.convertCache = src;
+	switch (format) {
+		default:
+		case DefaultType:
+		case String:
+			return vt;
+		case Nul:
+			return Null();
+		case Bool:
+			return vt.as<bool>();
+		case Int:
+			return vt.as<int64_t>();
+		case Float:
+			return vt.as<double>();
+		case DateTime:
+			return vt.as<boost::posix_time::ptime>();
+	}
+}
+
+VariableType
+VariableType::make(const Glib::ustring & src)
+{
+	if (src.empty()) {
+		return Null();
+	}
+	else if (boost::algorithm::all(src, g_unichar_isdigit)) {
+		return VariableType(src).as<int64_t>();
+	}
+	else if (boost::algorithm::all(src, [](gunichar c){ return c == '.' || g_unichar_isdigit(c); })) {
+		return VariableType(src).as<double>();
+	}
+	else {
+		try {
+			return VariableType(src).as<bool>();
+		}
+		catch (...) {
+			try {
+				return VariableType(src).as<boost::posix_time::ptime>();
+			}
+			catch (...) {
+				return src;
+			}
+		}
+	}
+}
+
+VariableType::VariableType()
+{
+}
+
+#define VTCONS(Source) \
+VariableType::VariableType(const Source & t) : \
+	_VT(t) \
+{ \
+}
+#define VTCONSD(Source, Store) \
+VariableType::VariableType(const Source & t) : \
+	_VT(Store(t)) \
+{ \
+}
+#define VTCONSC(Source, Store, Cast) \
+VariableType::VariableType(const Source & t) : \
+	_VT(Store((Cast)t)) \
+{ \
+}
+#define VTCONSN(Source, Store) \
+VariableType::VariableType(const Source & t) : \
+	_VT(boost::numeric_cast<Store>(t)) \
+{ \
+}
+
+VTCONS(Null);
+VTCONS(boost::posix_time::ptime);
+VTCONS(Glib::ustring);
+VTCONSD(bool, Boolean);
+VTCONSN(float, double);
+VTCONSN(double, double);
+VTCONSN(int, int64_t);
+VTCONSN(unsigned int, int64_t);
+VTCONSN(long int, int64_t);
+VTCONSN(long unsigned int, int64_t);
+VTCONSN(long long int, int64_t);
+VTCONSN(long long unsigned int, int64_t);
+VTCONSD(std::string, Glib::ustring);
+VTCONSD(char * const, Glib::ustring);
+VTCONSC(unsigned char * const, Glib::ustring, const char * const);
+
+VariableType::VariableType(const struct tm & vt) :
+	_VT(boost::posix_time::ptime_from_tm(vt))
+{
+}
+
+VariableType::VariableType(const VariableType & vt) :
+	_VT(*((const _VT *)&vt)),
+	convertCache(vt.convertCache)
+{
+}
+
+template <class S, typename Op>
+class compi : public boost::static_visitor<bool> {
+	public:
+		compi(const S & s) : _s(s) { }
+		bool operator()(const S & t) const
+		{
+			return Op()(t, _s);
+		}
+		template <class T>
+		bool operator()(const T &) const
+		{
+			// should never be called
+			throw std::logic_error("Shouldn't ever be comparing variables of different type");
+		}
+	private:
+		const S & _s;
+};
+
+template <template <class T> class Op>
+class comp : public boost::static_visitor<bool> {
+	public:
+		comp(const VariableType & a) : _a(a) { }
+		template <class T>
+		bool operator()(const T & t) const
+		{
+			return boost::apply_visitor(compi<T, Op<T>>(t), _a);
+		}
+	private:
+		const VariableType & _a;
+};
+
+bool
+VariableType::operator<(const VariableType & b) const
+{
+	if (this->which() < b.which()) {
+		return true;
+	}
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::less>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::operator==(const VariableType & b) const
+{
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::equal_to>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::operator<=(const VariableType & b) const
+{
+	if (this->which() < b.which()) {
+		return true;
+	}
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::less_equal>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::operator>(const VariableType & b) const
+{
+	if (this->which() > b.which()) {
+		return true;
+	}
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::greater>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::operator>=(const VariableType & b) const
+{
+	if (this->which() > b.which()) {
+		return true;
+	}
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::greater_equal>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::operator!=(const VariableType & b) const
+{
+	if (this->which() != b.which()) {
+		return true;
+	}
+	if (this->which() == b.which()) {
+		return boost::apply_visitor(comp<std::not_equal_to>(*this), b);
+	}
+	return false;
+}
+
+bool
+VariableType::isNull() const
+{
+	return (get<Null>());
+}
+
diff --git a/project2/common/variableType.h b/project2/common/variableType.h
new file mode 100644
index 0000000..21c2c39
--- /dev/null
+++ b/project2/common/variableType.h
@@ -0,0 +1,105 @@
+#ifndef VARIABLETYPE_H
+#define VARIABLETYPE_H
+
+#include <boost/any.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <glibmm/ustring.h>
+#include <boost/variant.hpp>
+#include <boost/optional.hpp>
+
+enum VT_typeID {
+	DefaultType,
+	Nul,
+	String,
+	Bool,
+	Int,
+	Float,
+	DateTime,
+};
+
+class Null {
+	public:
+		bool operator<(const Null &) const { return false; }
+		bool operator<=(const Null &) const { return false; }
+		bool operator>(const Null &) const { return false; }
+		bool operator>=(const Null &) const { return false; }
+		bool operator!=(const Null &) const { return false; }
+		bool operator==(const Null &) const { return true; }
+};
+
+class Boolean {
+	public:
+		Boolean(bool v);
+		bool operator<(const Boolean &) const;
+		operator bool() const;
+		bool value;
+};
+
+std::basic_ostream<char> & operator<<(std::basic_ostream<char> &, const Boolean &);
+std::basic_ostream<unsigned char> & operator<<(std::basic_ostream<unsigned char> &, const Boolean &);
+
+typedef boost::variant<
+	// Other
+	Null,
+	Boolean,
+	// Strings
+	Glib::ustring,
+	// Numbers
+	int64_t,
+	double,
+	// Date and Times
+	boost::posix_time::ptime
+	> _VT;
+
+class VariableType : public _VT {
+	public:
+		VariableType(const unsigned char * const & t);
+		VariableType(const char * const & t);
+		VariableType(const std::string &);
+		VariableType(const Glib::ustring &);
+		VariableType(const struct tm &);
+		VariableType(const boost::posix_time::ptime &);
+		VariableType(const Null &);
+		VariableType(const bool &);
+		VariableType(const int &);
+		VariableType(const unsigned int &);
+		VariableType(const long int &);
+		VariableType(const long unsigned int &);
+		VariableType(const long long int &);
+		VariableType(const long long unsigned int &);
+		VariableType(const float &);
+		VariableType(const double &);
+		VariableType();
+		VariableType(const VariableType &);
+
+		static VariableType make(const Glib::ustring & src, VT_typeID format);
+		static VariableType make(const Glib::ustring & src);
+		static VT_typeID getTypeFromName(const std::string & src);
+
+		bool operator<(const VariableType &) const;
+		bool operator<=(const VariableType &) const;
+		bool operator>(const VariableType &) const;
+		bool operator>=(const VariableType &) const;
+		bool operator==(const VariableType &) const;
+		bool operator!=(const VariableType &) const;
+
+		operator const Glib::ustring &() const;
+		operator const std::string &() const;
+		operator const char *() const;
+		operator const unsigned char *() const;
+		operator int64_t() const;
+		operator int32_t() const;
+		operator double() const;
+		operator const boost::posix_time::ptime &() const;
+		template <typename T> operator boost::optional<T>() const { return isNull() ? boost::optional<T>() : as<T>(); }
+		operator bool() const;
+		bool isNull() const;
+		template <typename T> T as() const { return *this; }
+		template <typename T> const T * get() const { return boost::get<T>(this); }
+
+		typedef boost::any ConvertCache;
+		mutable ConvertCache convertCache;
+};
+
+#endif
+
diff --git a/project2/common/variables.cpp b/project2/common/variables.cpp
index 7dcf243..6f62dc1 100644
--- a/project2/common/variables.cpp
+++ b/project2/common/variables.cpp
@@ -14,250 +14,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-SimpleMessageException(UnknownVariableType);
-
-Boolean::Boolean(bool v) : value(v)
-{
-}
-
-bool
-Boolean::operator<(const Boolean & b) const
-{
-	return ((this->value == false) && (b.value == true));
-}
-
-Boolean::operator bool() const
-{
-	return this->value;
-}
-
-std::basic_ostream<char> &
-operator<<(std::basic_ostream<char> & os, const Boolean & b)
-{
-	os << (b.value ? "true" : "false");
-	return os;
-}
-
-std::basic_ostream<unsigned char> &
-operator<<(std::basic_ostream<unsigned char> & os, const Boolean & b)
-{
-	os << (b.value ? "true" : "false");
-	return os;
-}
-
-VT_typeID
-VariableType::getTypeFromName(const std::string & src)
-{
-	if (src.empty()) return String;
-	if (src == "string") return String;
-	if (src == "bool") return Bool;
-	if (src == "int") return Int;
-	if (src == "float") return Float;
-	if (src == "datetime") return DateTime;
-	if (src == "null") return Nul;
-	throw UnknownVariableType(src);
-}
-
-SimpleMessageException(DateParseError);
-VariableType
-VariableType::make(const Glib::ustring & src, const VT_typeID format)
-{
-	VariableType vt;
-	switch (format) {
-		default:
-		case DefaultType:
-		case String:
-			vt = src;
-			return vt;
-		case Nul:
-			return Null();
-		case Bool:
-			vt = boost::lexical_cast<bool>(src);
-			break;
-		case Int:
-			vt = boost::lexical_cast<int64_t>(src);
-			break;
-		case Float:
-			vt = boost::lexical_cast<double>(src);
-			break;
-		case DateTime:
-			{
-				struct tm tm;
-				memset(&tm, 0, sizeof(struct tm));
-				mktime(&tm);
-				const char * e = strptime(src.c_str(), "%FT%T", &tm);
-				if (!e || *e) {
-					Logger()->messagef(LOG_ERR, "%s: check failed (parse) for '%s' against '%s' (remaining chars='%s')",
-							__PRETTY_FUNCTION__, src.c_str(), "%FT%T", e);
-					throw DateParseError(src);
-				}
-				vt = boost::posix_time::ptime_from_tm(tm);
-			}
-			break;
-	}
-	vt.convertCache = src;
-	return vt;
-}
-
-VariableType::VariableType()
-{
-}
-
-#define VTCONS(Source) \
-VariableType::VariableType(const Source & t) : \
-	_VT(t) \
-{ \
-}
-#define VTCONSD(Source, Store) \
-VariableType::VariableType(const Source & t) : \
-	_VT(Store(t)) \
-{ \
-}
-#define VTCONSC(Source, Store, Cast) \
-VariableType::VariableType(const Source & t) : \
-	_VT(Store((Cast)t)) \
-{ \
-}
-#define VTCONSN(Source, Store) \
-VariableType::VariableType(const Source & t) : \
-	_VT(boost::numeric_cast<Store>(t)) \
-{ \
-}
-
-VTCONS(Null);
-VTCONS(boost::posix_time::ptime);
-VTCONS(Glib::ustring);
-VTCONSD(bool, Boolean);
-VTCONSN(float, double);
-VTCONSN(double, double);
-VTCONSN(int, int64_t);
-VTCONSN(unsigned int, int64_t);
-VTCONSN(long int, int64_t);
-VTCONSN(long unsigned int, int64_t);
-VTCONSN(long long int, int64_t);
-VTCONSN(long long unsigned int, int64_t);
-VTCONSD(std::string, Glib::ustring);
-VTCONSD(char * const, Glib::ustring);
-VTCONSC(unsigned char * const, Glib::ustring, const char * const);
-
-VariableType::VariableType(const struct tm & vt) :
-	_VT(boost::posix_time::ptime_from_tm(vt))
-{
-}
-
-VariableType::VariableType(const VariableType & vt) :
-	_VT(*((const _VT *)&vt)),
-	convertCache(vt.convertCache)
-{
-}
-
-template <class S, typename Op>
-class compi : public boost::static_visitor<bool> {
-	public:
-		compi(const S & s) : _s(s) { }
-		bool operator()(const S & t) const
-		{
-			return Op()(t, _s);
-		}
-		template <class T>
-		bool operator()(const T &) const
-		{
-			// should never be called
-			throw std::logic_error("Shouldn't ever be comparing variables of different type");
-		}
-	private:
-		const S & _s;
-};
-
-template <template <class T> class Op>
-class comp : public boost::static_visitor<bool> {
-	public:
-		comp(const VariableType & a) : _a(a) { }
-		template <class T>
-		bool operator()(const T & t) const
-		{
-			return boost::apply_visitor(compi<T, Op<T>>(t), _a);
-		}
-	private:
-		const VariableType & _a;
-};
-
-bool
-VariableType::operator<(const VariableType & b) const
-{
-	if (this->which() < b.which()) {
-		return true;
-	}
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::less>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::operator==(const VariableType & b) const
-{
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::equal_to>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::operator<=(const VariableType & b) const
-{
-	if (this->which() < b.which()) {
-		return true;
-	}
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::less_equal>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::operator>(const VariableType & b) const
-{
-	if (this->which() > b.which()) {
-		return true;
-	}
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::greater>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::operator>=(const VariableType & b) const
-{
-	if (this->which() > b.which()) {
-		return true;
-	}
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::greater_equal>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::operator!=(const VariableType & b) const
-{
-	if (this->which() != b.which()) {
-		return true;
-	}
-	if (this->which() == b.which()) {
-		return boost::apply_visitor(comp<std::not_equal_to>(*this), b);
-	}
-	return false;
-}
-
-bool
-VariableType::isNull() const
-{
-	return (get<Null>());
-}
 
 VariableImplDyn::VariableImplDyn(ScriptNodePtr e)
 {
diff --git a/project2/common/variables.h b/project2/common/variables.h
index 68923b5..dbb4c34 100644
--- a/project2/common/variables.h
+++ b/project2/common/variables.h
@@ -3,109 +3,14 @@
 
 #include <boost/intrusive_ptr.hpp>
 #include <boost/optional.hpp>
-#include <boost/any.hpp>
-#include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <stdint.h>
-#include <glibmm/ustring.h>
 #include "intrusivePtrBase.h"
 #include "scriptLoader.h"
-#include <boost/variant.hpp>
+#include "variableType.h"
 #include <boost/shared_ptr.hpp>
 
 SimpleMessageException(UnknownVariableSource);
 
-enum VT_typeID {
-	DefaultType,
-	Nul,
-	String,
-	Bool,
-	Int,
-	Float,
-	DateTime,
-};
-
-class Null {
-	public:
-		bool operator<(const Null &) const { return false; }
-		bool operator<=(const Null &) const { return false; }
-		bool operator>(const Null &) const { return false; }
-		bool operator>=(const Null &) const { return false; }
-		bool operator!=(const Null &) const { return false; }
-		bool operator==(const Null &) const { return true; }
-};
-
-class Boolean {
-	public:
-		Boolean(bool v);
-		bool operator<(const Boolean &) const;
-		operator bool() const;
-		bool value;
-};
-
-std::basic_ostream<char> & operator<<(std::basic_ostream<char> &, const Boolean &);
-std::basic_ostream<unsigned char> & operator<<(std::basic_ostream<unsigned char> &, const Boolean &);
-
-typedef boost::variant<
-	// Other
-	Null,
-	Boolean,
-	// Strings
-	Glib::ustring,
-	// Numbers
-	int64_t,
-	double,
-	// Date and Times
-	boost::posix_time::ptime
-	> _VT;
-
-class VariableType : public _VT {
-	public:
-		VariableType(const unsigned char * const & t);
-		VariableType(const char * const & t);
-		VariableType(const std::string &);
-		VariableType(const Glib::ustring &);
-		VariableType(const struct tm &);
-		VariableType(const boost::posix_time::ptime &);
-		VariableType(const Null &);
-		VariableType(const bool &);
-		VariableType(const int &);
-		VariableType(const unsigned int &);
-		VariableType(const long int &);
-		VariableType(const long unsigned int &);
-		VariableType(const long long int &);
-		VariableType(const long long unsigned int &);
-		VariableType(const float &);
-		VariableType(const double &);
-		VariableType();
-		VariableType(const VariableType &);
-
-		static VariableType make(const Glib::ustring & src, const VT_typeID format = DefaultType);
-		static VT_typeID getTypeFromName(const std::string & src);
-
-		bool operator<(const VariableType &) const;
-		bool operator<=(const VariableType &) const;
-		bool operator>(const VariableType &) const;
-		bool operator>=(const VariableType &) const;
-		bool operator==(const VariableType &) const;
-		bool operator!=(const VariableType &) const;
-
-		operator const Glib::ustring &() const;
-		operator const std::string &() const;
-		operator const char *() const;
-		operator const unsigned char *() const;
-		operator int64_t() const;
-		operator int32_t() const;
-		operator double() const;
-		operator const boost::posix_time::ptime &() const;
-		operator bool() const;
-		bool isNull() const;
-		template <typename T> T as() const { return *this; }
-		template <typename T> const T * get() const { return boost::get<T>(this); }
-
-		typedef boost::any ConvertCache;
-		mutable ConvertCache convertCache;
-};
-
 /// Base class for Project2 variable accessors
 class VariableImpl : public IntrusivePtrBase {
 	public:
diff --git a/project2/common/variables/config.cpp b/project2/common/variables/config.cpp
index 67014c4..51759d5 100644
--- a/project2/common/variables/config.cpp
+++ b/project2/common/variables/config.cpp
@@ -5,7 +5,7 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include "../appEngine.h"
 
-typedef std::map<Glib::ustring, Glib::ustring> ConfigOptions;
+typedef std::map<Glib::ustring, VariableType> ConfigOptions;
 static ConfigOptions cfgOpts;
 
 SimpleMessageException(NoSuchConfigurationValue);
@@ -40,7 +40,7 @@ class VariableConfigLoader : public VariableLoader::For<VariableConfig> {
 				void reset() const {
 					cfgOpts.clear();
 				}
-				void consume(const Glib::ustring & n, const Glib::ustring & p, const Glib::ustring & v) const {
+				void consume(const Glib::ustring & n, const Glib::ustring & p, const VariableType & v) const {
 					if (boost::algorithm::starts_with(n, "application.")) {
 						Glib::ustring k(n.substr(12));
 						const ConfigOptions::iterator i = cfgOpts.find(k);
diff --git a/project2/console/consoleEnvironment.cpp b/project2/console/consoleEnvironment.cpp
index 09f4572..3fcaf7d 100644
--- a/project2/console/consoleEnvironment.cpp
+++ b/project2/console/consoleEnvironment.cpp
@@ -32,7 +32,7 @@ class ShowHelpTrigger : public Options::Target {
 		bool paramRequired() const {
 			return false;
 		}
-		void consume(const Glib::ustring &, const Glib::ustring &) const {
+		void consume(const Glib::ustring &, const VariableType &) const {
 			fprintf(stdout, "Help\n");
 			exit(1);
 		}
diff --git a/project2/streams/streamNvpRows.cpp b/project2/streams/streamNvpRows.cpp
index 895826a..2577ffa 100644
--- a/project2/streams/streamNvpRows.cpp
+++ b/project2/streams/streamNvpRows.cpp
@@ -115,8 +115,7 @@ class StreamNvpRows : public RowSet {
 				}
 
 				bool newValue(size_t start) {
-					fields.back() =
-						boost::algorithm::trim_copy_if(tok.substr(0, start), g_unichar_isspace);
+					fields.back() = VariableType::make(boost::algorithm::trim_copy_if(tok.substr(0, start), g_unichar_isspace));
 					inValue = false;
 					return true;
 				}
-- 
cgit v1.2.3