/builddir/build/BUILD/libutil++-1.4.0/src/sella/variant/Variant.h

/*
** libutil++
** $Id: Variant.h 1203 2014-10-18 21:16:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__variant__Variant_H__
#define __libutilxx__sella__variant__Variant_H__

#include "../../common.h"
#include "TypeCastException.h"
#include "UnsupportedOperatorException.h"
#include "Nullable.h"
#include "Null.h"
#include "Boolean.h"
#include "Signed.h"
#include "Unsigned.h"
#include "Double.h"
#include "String.h"
#include "UUID.h"
#include "Binary.h"
#include "Pointer.h"
#include "IPAddress.h"
#include "IPPrefix.h"
#include "Interval.h"
#include "Time.h"
#include "Date.h"
#include "TimeStamp.h"
#include "Vector.h"
#include "Object.h"

#include <ctype.h>
#include <iostream>
#include <memory>
#include <algorithm>

#include <boost/regex.hpp>
#include <boost/iterator/iterator_facade.hpp>

namespace sella {
        namespace variant {
                class Variant;
                class Variant_iterator;

                struct iterator_t {
                        int type;
                        std::vector<Variant>::iterator vit;
                        std::map<std::string, Variant>::iterator oit;
                        Variant *v;
                };
        }
}

class sella::variant::Variant {
        public:
                typedef std::shared_ptr<Variant> shared;
                typedef Variant                                         *ptr;
                typedef Variant_iterator                        iterator;
                typedef const Variant_iterator  const_iterator;

        public:
                /* Public Static Attributes */
                const static int TypeAuto                       = 0x00;

                const static int TypeNull                       = 0x01;

                const static int TypeBoolean            = 0x02;
                const static int TypeSigned             = 0x03;
                const static int TypeUnsigned           = 0x04;
                const static int TypeDouble             = 0x05;
                const static int TypeString             = 0x06;
                const static int TypeUUID                       = 0x07;
                const static int TypeBinary             = 0x08;
                const static int TypePointer            = 0x09;
                const static int TypeIPAddress  = 0x10;
                const static int TypeIPPrefix           = 0x11;

                const static int TypeInterval           = 0x20;
                const static int TypeTime                       = 0x21;
                const static int TypeDate                       = 0x22;
                const static int TypeTimeStamp  = 0x23;

                const static int TypeVector             = 0x50;
                const static int TypeObject             = 0x51;

                const static int JSON                           = 0x00;
                const static int XML                                    = 0x01;

                const static int IterScalar             = 0x00;
                const static int IterVector             = 0x01;
                const static int IterObject             = 0x02;

                /* Constructors */
                Variant() throw ();
                Variant(std::shared_ptr<Nullable> value, int type) throw (TypeCastException);
                Variant(const char *value, int type = TypeAuto) throw (TypeCastException); /* TypeAuto chosen to make auto casting to Variant work as expected. */
                Variant(const std::string &value, int type = TypeString) throw (TypeCastException);
                Variant(const sella::util::UUID &value) throw ();
                Variant(uuid_t &value) throw ();
                Variant(void *ptr) throw ();
                Variant(bool value) throw ();
                Variant(uint8_t value) throw ();
                Variant(uint16_t value) throw ();
                Variant(uint32_t value) throw ();
                Variant(uint64_t value) throw ();
                Variant(int8_t value) throw ();
                Variant(int16_t value) throw ();
                Variant(int32_t value) throw ();
                Variant(int64_t value) throw ();
                Variant(float value) throw ();
                Variant(double value) throw ();
                Variant(const std::vector<std::string> &token) throw (TypeCastException);
#ifdef __LP64__
                Variant(unsigned long long value) throw ();
                Variant(long long value) throw ();
#else
                Variant(unsigned long value) throw ();
                Variant(long value) throw ();
#endif

                Variant(const Variant &other) throw ();
                Variant(const Variant &&other) throw ();
                virtual ~Variant() throw ();

                iterator begin() throw ();
                iterator end() throw ();

                /* Public Member Functions */
                int getType() const throw (UnsupportedOperatorException);
                void setType(int type) throw (TypeCastException);
                const char* getTypeName(int type = -1) const throw ();
                Variant& parse(const std::string &value, int type = TypeAuto) throw (TypeCastException);
                void clear() throw ();
                size_t size() const throw ();
                bool empty() const throw ();
                bool isScalar() const throw ();
                bool isNumeric() const throw ();
                bool isTemporal() const throw ();
                bool isNull() const throw ();
                bool isBoolean() const throw ();
                bool isSigned() const throw ();
                bool isUnsigned() const throw ();
                bool isDouble() const throw ();
                bool isString() const throw ();
                bool isUUID() const throw ();
                bool isBinary() const throw ();
                bool isPointer() const throw ();
                bool isIPAddress() const throw ();
                bool isIPPrefix() const throw ();
                bool isInterval() const throw ();
                bool isTime() const throw ();
                bool isDate() const throw ();
                bool isTimeStamp() const throw ();
                bool isVector() const throw ();
                bool isObject() const throw ();

                template <class T> bool contains(const T &value) throw (UnsupportedOperatorException) {
                        Variant v(value);

                        if (getType() == TypeObject) {
                                const auto &r = *(get<Object>().getObject());

                                return (r.find(v.str()) != r.end());
                        } else if (getType() == TypeVector) {
                                const auto &r = *(get<Vector>().getVector());

                                return (std::find(r.begin(), r.end(), v) != r.end());
                        }

                        return (*this == v);
                }

                bool erase(const Variant &value) throw ();
                bool erase(int index) throw ();
                void shrink_to_fit() throw ();

                template <class T> void push_back(const T &value) throw (UnsupportedOperatorException) {
                        if (getType() != TypeVector) {
                                (*this)[0] = value; /* Forces conversion and assigns. */
                        } else {
                                *this += value;
                        }
                }

                template <class T> const T& get() const throw () {
                        return *std::static_pointer_cast<T>(this->value);
                }

                template <class T> T& get() throw () {
                        return *std::static_pointer_cast<T>(this->value);
                }

                template <class T> T cast() const throw (TypeCastException);

                const std::string& str(int type = JSON) const throw ();
                const char* c_str(int type = JSON) const throw ();

                const std::string& json(void) const throw () { return str(JSON); }
                const char* c_json(void) const throw () { return c_str(JSON); }
                const std::string& xml(void) const throw () { return str(XML); }
                const char* c_xml(void) const throw () { return c_str(XML); }

                /* Operators - See Operators.cpp */
                Variant& operator=(const Variant &other) throw ();
                Variant& operator=(const Variant &&other) throw ();
                Variant& operator=(const std::string &value) throw ();
                Variant& operator=(const char *value) throw ();
                Variant& operator=(const sella::util::UUID &value) throw ();
                Variant& operator=(uuid_t &value) throw ();
                Variant& operator=(void *ptr) throw (); /* Must assign as '(void*) NULL' to use. */
                Variant& operator=(bool value) throw ();
                Variant& operator=(uint8_t value) throw ();
                Variant& operator=(uint16_t value) throw ();
                Variant& operator=(uint32_t value) throw ();
                Variant& operator=(uint64_t value) throw ();
                Variant& operator=(int8_t value) throw ();
                Variant& operator=(int16_t value) throw ();
                Variant& operator=(int32_t value) throw ();
                Variant& operator=(int64_t value) throw ();
                Variant& operator=(float value) throw ();
                Variant& operator=(double value) throw ();
#ifdef __LP64__
                Variant& operator=(unsigned long long value) throw ();
                Variant& operator=(long long value) throw ();
#else
                Variant& operator=(unsigned long value) throw ();
                Variant& operator=(long value) throw ();
#endif

                bool operator!() throw (UnsupportedOperatorException);
                Variant& operator++() throw (UnsupportedOperatorException);
                Variant operator++(int) throw (UnsupportedOperatorException);
                Variant& operator--() throw (UnsupportedOperatorException);
                Variant operator--(int) throw (UnsupportedOperatorException);

                const Variant& operator[](const char *key) const throw ();
                const Variant& operator[](const std::string &key) const throw ();
                Variant& operator[](const char *key) throw ();
                Variant& operator[](const std::string &key) throw ();
                const Variant& operator[](int index) const throw (UnsupportedOperatorException);
                Variant& operator[](int index) throw (UnsupportedOperatorException);

                operator const char*() const throw (TypeCastException);
                operator const std::string&() const throw (TypeCastException);
                operator sella::util::UUID() const throw (TypeCastException);
                operator bool() const throw (TypeCastException);
                operator uint8_t() const throw (TypeCastException);
                operator uint16_t() const throw (TypeCastException);
                operator uint32_t() const throw (TypeCastException);
                operator uint64_t() const throw (TypeCastException);
                operator int8_t() const throw (TypeCastException);
                operator int16_t() const throw (TypeCastException);
                operator int32_t() const throw (TypeCastException);
                operator int64_t() const throw (TypeCastException);
                operator float() const throw (TypeCastException);
                operator double() const throw (TypeCastException);
#ifdef __LP64__
                operator unsigned long long() const throw (TypeCastException);
                operator long long() const throw (TypeCastException);
#else
                operator unsigned long() const throw (TypeCastException);
                operator long() const throw (TypeCastException);
#endif
                operator void*() const throw (TypeCastException);

                /* Friends */
                friend bool operator==(const Variant &a, const Variant &b) throw ();
                friend bool operator!=(const Variant &a, const Variant &b) throw ();
                friend bool operator>(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend bool operator<(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend bool operator>=(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend bool operator<=(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);

                friend Variant& operator+=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator-=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator*=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator/=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator^=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator%=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator&=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator|=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator<<=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant& operator>>=(Variant &a, const Variant &b) throw (UnsupportedOperatorException);

                friend Variant operator+(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator-(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator*(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator/(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator^(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator%(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator&(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator|(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator<<(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);
                friend Variant operator>>(const Variant &a, const Variant &b) throw (UnsupportedOperatorException);

                /* Specialized operators */
                friend bool operator==(const Variant &a, const char *b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(const char *a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, const std::string &b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(const std::string &a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, bool b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(bool a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(uint8_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, uint8_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(uint16_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, uint16_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(uint32_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, uint32_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(uint64_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, uint64_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(int16_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, int16_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(int32_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, int32_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(int64_t a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, int64_t b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(float a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, float b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(double a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, double b) throw (TypeCastException) { return a == Variant(b); }
#ifdef __LP64__
                friend bool operator==(unsigned long long a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, unsigned long long b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(long long a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, long long b) throw (TypeCastException) { return a == Variant(b); }
#else
                friend bool operator==(unsigned long a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, unsigned long b) throw (TypeCastException) { return a == Variant(b); }
                friend bool operator==(long a, const Variant &b) throw (TypeCastException) { return Variant(a) == b; }
                friend bool operator==(const Variant &a, long b) throw (TypeCastException) { return a == Variant(b); }
#endif

                friend bool operator!=(const Variant &a, const char *b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(const char *a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, const std::string &b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(const std::string &a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, bool b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(bool a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(uint8_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, uint8_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(uint16_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, uint16_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(uint32_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, uint32_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(uint64_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, uint64_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(int16_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, int16_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(int32_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, int32_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(int64_t a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, int64_t b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(float a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, float b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(double a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, double b) throw (TypeCastException) { return a != Variant(b); }
#ifdef __LP64__
                friend bool operator!=(unsigned long long a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, unsigned long long b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(long long a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, long long b) throw (TypeCastException) { return a != Variant(b); }
#else
                friend bool operator!=(unsigned long a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, unsigned long b) throw (TypeCastException) { return a != Variant(b); }
                friend bool operator!=(long a, const Variant &b) throw (TypeCastException) { return Variant(a) != b; }
                friend bool operator!=(const Variant &a, long b) throw (TypeCastException) { return a != Variant(b); }
#endif

                friend bool operator>(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, float b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, double b) throw (UnsupportedOperatorException) { return a > Variant(b); }
#ifdef __LP64__
                friend bool operator>(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a > Variant(b); }
#else
                friend bool operator>(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a > Variant(b); }
                friend bool operator>(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) > b; }
                friend bool operator>(const Variant &a, long b) throw (UnsupportedOperatorException) { return a > Variant(b); }
#endif

                friend bool operator<(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, float b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, double b) throw (UnsupportedOperatorException) { return a < Variant(b); }
#ifdef __LP64__
                friend bool operator<(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a < Variant(b); }
#else
                friend bool operator<(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a < Variant(b); }
                friend bool operator<(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) < b; }
                friend bool operator<(const Variant &a, long b) throw (UnsupportedOperatorException) { return a < Variant(b); }
#endif

                friend bool operator>=(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, float b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, double b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
#ifdef __LP64__
                friend bool operator>=(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
#else
                friend bool operator>=(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
                friend bool operator>=(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >= b; }
                friend bool operator>=(const Variant &a, long b) throw (UnsupportedOperatorException) { return a >= Variant(b); }
#endif

                friend bool operator<=(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, float b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, double b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
#ifdef __LP64__
                friend bool operator<=(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
#else
                friend bool operator<=(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
                friend bool operator<=(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) <= b; }
                friend bool operator<=(const Variant &a, long b) throw (UnsupportedOperatorException) { return a <= Variant(b); }
#endif

                friend Variant operator+(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, float b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, double b) throw (UnsupportedOperatorException) { return a + Variant(b); }
#ifdef __LP64__
                friend Variant operator+(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a + Variant(b); }
#else
                friend Variant operator+(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a + Variant(b); }
                friend Variant operator+(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) + b; }
                friend Variant operator+(const Variant &a, long b) throw (UnsupportedOperatorException) { return a + Variant(b); }
#endif

                friend Variant operator-(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, float b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, double b) throw (UnsupportedOperatorException) { return a - Variant(b); }
#ifdef __LP64__
                friend Variant operator-(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a - Variant(b); }
#else
                friend Variant operator-(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a - Variant(b); }
                friend Variant operator-(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) - b; }
                friend Variant operator-(const Variant &a, long b) throw (UnsupportedOperatorException) { return a - Variant(b); }
#endif

                friend Variant operator*(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, float b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, double b) throw (UnsupportedOperatorException) { return a * Variant(b); }
#ifdef __LP64__
                friend Variant operator*(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a * Variant(b); }
#else
                friend Variant operator*(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a * Variant(b); }
                friend Variant operator*(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) * b; }
                friend Variant operator*(const Variant &a, long b) throw (UnsupportedOperatorException) { return a * Variant(b); }
#endif

                friend Variant operator/(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(float a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, float b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(double a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, double b) throw (UnsupportedOperatorException) { return a / Variant(b); }
#ifdef __LP64__
                friend Variant operator/(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a / Variant(b); }
#else
                friend Variant operator/(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a / Variant(b); }
                friend Variant operator/(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) / b; }
                friend Variant operator/(const Variant &a, long b) throw (UnsupportedOperatorException) { return a / Variant(b); }
#endif

                friend Variant operator^(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
#ifdef __LP64__
                friend Variant operator^(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
#else
                friend Variant operator^(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
                friend Variant operator^(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) ^ b; }
                friend Variant operator^(const Variant &a, long b) throw (UnsupportedOperatorException) { return a ^ Variant(b); }
#endif

                friend Variant operator%(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a % Variant(b); }
#ifdef __LP64__
                friend Variant operator%(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a % Variant(b); }
#else
                friend Variant operator%(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a % Variant(b); }
                friend Variant operator%(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) % b; }
                friend Variant operator%(const Variant &a, long b) throw (UnsupportedOperatorException) { return a % Variant(b); }
#endif

                friend Variant operator&(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a & Variant(b); }
#ifdef __LP64__
                friend Variant operator&(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a & Variant(b); }
#else
                friend Variant operator&(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a & Variant(b); }
                friend Variant operator&(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) & b; }
                friend Variant operator&(const Variant &a, long b) throw (UnsupportedOperatorException) { return a & Variant(b); }
#endif

                friend Variant operator|(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a | Variant(b); }
#ifdef __LP64__
                friend Variant operator|(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a | Variant(b); }
#else
                friend Variant operator|(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a | Variant(b); }
                friend Variant operator|(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) | b; }
                friend Variant operator|(const Variant &a, long b) throw (UnsupportedOperatorException) { return a | Variant(b); }
#endif

                friend Variant operator>>(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
#ifdef __LP64__
                friend Variant operator>>(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
#else
                friend Variant operator>>(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
                friend Variant operator>>(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) >> b; }
                friend Variant operator>>(const Variant &a, long b) throw (UnsupportedOperatorException) { return a >> Variant(b); }
#endif

                friend Variant operator<<(const Variant &a, const char *b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(const char *a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, const std::string &b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(const std::string &a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, bool b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(bool a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(uint8_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, uint8_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(uint16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, uint16_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(uint32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, uint32_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(uint64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, uint64_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(int16_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, int16_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(int32_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, int32_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(int64_t a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, int64_t b) throw (UnsupportedOperatorException) { return a << Variant(b); }
#ifdef __LP64__
                friend Variant operator<<(unsigned long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, unsigned long long b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(long long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, long long b) throw (UnsupportedOperatorException) { return a << Variant(b); }
#else
                friend Variant operator<<(unsigned long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, unsigned long b) throw (UnsupportedOperatorException) { return a << Variant(b); }
                friend Variant operator<<(long a, const Variant &b) throw (UnsupportedOperatorException) { return Variant(a) << b; }
                friend Variant operator<<(const Variant &a, long b) throw (UnsupportedOperatorException) { return a << Variant(b); }
#endif

                friend std::istream& operator>>(std::istream &is, Variant &value) throw (TypeCastException);
                friend std::ostream& operator<<(std::ostream &os, const Variant &value) throw (TypeCastException);

        private:
                std::shared_ptr<Nullable>       value;
                int                                                             type;
                mutable std::string                     cache;
};

namespace sella {
        namespace variant {
                template <> inline const char* Variant::cast<const char*>() const throw (TypeCastException) {
                        return c_str();
                }

                template <> inline std::string Variant::cast<std::string>() const throw (TypeCastException) {
                        return str();
                }

                template <> inline const std::string& Variant::cast<const std::string&>() const throw (TypeCastException) {
                        return str();
                }

                template <> inline const sella::util::UUID Variant::cast<const sella::util::UUID>() const throw (TypeCastException) {
                        if (getType() != TypeUUID) {
                                THROW(TypeCastException, "unable to cast from %s to a UUID value", getTypeName());
                        }

                        return static_cast<sella::util::UUID>(*(this->get<sella::variant::UUID>().getUUID()));
                }

                template <> inline bool Variant::cast<bool>() const throw (TypeCastException) {
                        if (!this->value->isNull()) {
                                switch (this->getType()) {
                                        case TypeBoolean:
                                                return *(this->get<sella::variant::Boolean>().getBoolean());

                                        case TypeSigned:
                                                return static_cast<bool>(*(this->get<sella::variant::Signed>().getSigned()));

                                        case TypeUnsigned:
                                                return static_cast<bool>(*(this->get<sella::variant::Unsigned>().getUnsigned()));

                                        case TypeDouble:
                                                return static_cast<bool>(*(this->get<sella::variant::Double>().getDouble()));

                                        case TypeString:
                                                if (boost::regex_match(*(this->get<sella::variant::String>().getString()), Boolean::Pattern)) {
                                                        return (tolower((*this->get<sella::variant::String>().getString())[0]) == 't');
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to a boolean value (invalid string)", getTypeName());

                                        case TypeInterval:
                                                return static_cast<bool>(*(this->get<sella::variant::Interval>().getUsec()));

                                        case TypeTime:
                                                return static_cast<bool>(*(this->get<sella::variant::Time>().getUsec()));

                                        case TypeDate:
                                                return static_cast<bool>(*(this->get<sella::variant::Date>().getUsec()));

                                        case TypeTimeStamp:
                                                return static_cast<bool>(*(this->get<sella::variant::TimeStamp>().getUsec()));

                                        case TypeVector:
                                                return this->get<sella::variant::Vector>().empty();

                                        case TypeObject:
                                                return this->get<sella::variant::Object>().empty();

                                        case TypeBinary:
                                                return this->get<sella::variant::Binary>().empty();

                                        default:
                                                THROW(TypeCastException, "unable to cast from %s to bool", getTypeName());
                                }
                        }

                        return 0;
                }

                template <> inline uint64_t Variant::cast<uint64_t>() const throw (TypeCastException) {
                        if (!this->value->isNull()) {
                                switch (this->getType()) {
                                        case TypeBoolean:
                                                return *(this->get<sella::variant::Boolean>().getBoolean()) ? 1 : 0;

                                        case TypeSigned:
                                                if (*(this->get<sella::variant::Signed>().getSigned()) >= 0) {
                                                        return static_cast<uint64_t>(*(this->get<sella::variant::Signed>().getSigned()));
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeUnsigned:
                                                return *(this->get<sella::variant::Unsigned>().getUnsigned());

                                        case TypeDouble:
                                                if (*(this->get<sella::variant::Double>().getDouble()) >= 0) {
                                                        if (*(this->get<sella::variant::Double>().getDouble()) <= std::numeric_limits<uint64_t>::max()) {
                                                                return static_cast<uint64_t>(*(this->get<sella::variant::Double>().getDouble()));
                                                        }
                                                        THROW(TypeCastException, "unable to cast from %s to an unsigned value (value too large)", getTypeName());
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeString:
                                                try {
                                                        return std::stoull(*this->get<sella::variant::String>().getString());
                                                } catch (std::invalid_argument &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a signed value (invalid string)", getTypeName());
                                                } catch (std::out_of_range &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a signed value (overflow/underflow)", getTypeName());
                                                }

                                        case TypeInterval:
                                                if (*(this->get<sella::variant::Interval>().getUsec()) >= 0) {
                                                        return *(this->get<sella::variant::Interval>().getUsec());
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeTime:
                                                if (*(this->get<sella::variant::Time>().getUsec()) >= 0) {
                                                        return *(this->get<sella::variant::Time>().getUsec());
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeDate:
                                                if (*(this->get<sella::variant::Date>().getUsec()) >= 0) {
                                                        return *(this->get<sella::variant::Date>().getUsec());
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeTimeStamp:
                                                if (*(this->get<sella::variant::TimeStamp>().getUsec()) >= 0) {
                                                        return *(this->get<sella::variant::TimeStamp>().getUsec());
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to an unsigned value (value is negative)", getTypeName());

                                        case TypeVector:
                                        case TypeObject:
                                        case TypeBinary:
                                        default:
                                                THROW(TypeCastException, "unable to cast from %s to uint64_t", getTypeName());
                                }
                        }

                        return 0;
                }

                template <> inline uint32_t Variant::cast<uint32_t>() const throw (TypeCastException) {
                        return (uint32_t) this->cast<uint64_t>();
                }

                template <> inline uint16_t Variant::cast<uint16_t>() const throw (TypeCastException) {
                        return (uint16_t) this->cast<uint64_t>();
                }

                template <> inline uint8_t Variant::cast<uint8_t>() const throw (TypeCastException) {
                        return (uint8_t) this->cast<uint64_t>();
                }

                template <> inline int64_t Variant::cast<int64_t>() const throw (TypeCastException) {
                        if (!this->value->isNull()) {
                                switch (this->getType()) {
                                        case TypeBoolean:
                                                return *(this->get<sella::variant::Boolean>().getBoolean()) ? 1 : 0;

                                        case TypeSigned:
                                                return *(this->get<sella::variant::Signed>().getSigned());

                                        case TypeUnsigned:
                                                if (*(this->get<sella::variant::Unsigned>().getUnsigned()) <= static_cast<uint64_t>(std::numeric_limits<int64_t>::max())) {
                                                        return static_cast<int64_t>(*(this->get<sella::variant::Unsigned>().getUnsigned()));
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to a signed value (value too large)", getTypeName());

                                        case TypeDouble:
                                                if (*(this->get<sella::variant::Double>().getDouble()) < static_cast<double>(std::numeric_limits<int64_t>::max())) {
                                                        return static_cast<int64_t>(*(this->get<sella::variant::Double>().getDouble()));
                                                }
                                                THROW(TypeCastException, "unable to cast from %s to a signed value (value too large)", getTypeName());

                                        case TypeString:
                                                try {
                                                        return std::stoll(*this->get<sella::variant::String>().getString());
                                                } catch (std::invalid_argument &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a signed value (invalid string)", getTypeName());
                                                } catch (std::out_of_range &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a signed value (overflow/underflow)", getTypeName());
                                                }

                                        case TypeInterval:
                                                return *(this->get<sella::variant::Interval>().getUsec());

                                        case TypeTime:
                                                return *(this->get<sella::variant::Time>().getUsec());

                                        case TypeDate:
                                                return *(this->get<sella::variant::Date>().getUsec());

                                        case TypeTimeStamp:
                                                return *(this->get<sella::variant::TimeStamp>().getUsec());

                                        case TypeVector:
                                        case TypeObject:
                                        case TypeBinary:
                                        default:
                                                THROW(TypeCastException, "unable to cast from %s to int64_t", getTypeName());
                                }
                        }

                        return 0;
                }

                template <> inline int32_t Variant::cast<int32_t>() const throw (TypeCastException) {
                        return (int32_t) this->cast<int64_t>();
                }

                template <> inline int16_t Variant::cast<int16_t>() const throw (TypeCastException) {
                        return (int16_t) this->cast<int64_t>();
                }

                template <> inline int8_t Variant::cast<int8_t>() const throw (TypeCastException) {
                        return (int8_t) this->cast<int64_t>();
                }

                template <> inline double Variant::cast<double>() const throw (TypeCastException) {
                        if (!this->value->isNull()) {
                                switch (this->getType()) {
                                        case TypeBoolean:
                                                return *(this->get<sella::variant::Boolean>().getBoolean()) ? 1.0F : 0.0F;

                                        case TypeSigned:
                                                return static_cast<double>(*(this->get<sella::variant::Signed>().getSigned()));

                                        case TypeUnsigned:
                                                return static_cast<double>(*(this->get<sella::variant::Unsigned>().getUnsigned()));

                                        case TypeDouble:
                                                return *(this->get<sella::variant::Double>().getDouble());

                                        case TypeString:
                                                try {
                                                        return std::stod(*this->get<sella::variant::String>().getString());
                                                } catch (std::invalid_argument &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a decimal value (invalid string)", getTypeName());
                                                } catch (std::out_of_range &e) {
                                                        THROW(TypeCastException, "unable to cast from %s to a decimal value (overflow/underflow)", getTypeName());
                                                }

                                        case TypeInterval:
                                                return static_cast<double>(*(this->get<sella::variant::Interval>().getUsec()));

                                        case TypeTime:
                                                return static_cast<double>(*(this->get<sella::variant::Time>().getUsec()));

                                        case TypeDate:
                                                return static_cast<double>(*(this->get<sella::variant::Date>().getUsec()));

                                        case TypeTimeStamp:
                                                return static_cast<double>(*(this->get<sella::variant::TimeStamp>().getUsec()));

                                        case TypeVector:
                                        case TypeObject:
                                        case TypeBinary:
                                        default:
                                                THROW(TypeCastException, "unable to cast from %s to double", getTypeName());
                                }
                        }

                        return 0;
                }

                template <> inline float Variant::cast<float>() const throw (TypeCastException) {
                        return (float) this->cast<double>();
                }

#ifdef __LP64__
                template <> inline unsigned long long Variant::cast<unsigned long long>() const throw (TypeCastException) {
                        return (unsigned long long) this->cast<uint64_t>();
                }

                template <> inline long long Variant::cast<long long>() const throw (TypeCastException) {
                        return (long long) this->cast<int64_t>();
                }
#else
                template <> inline unsigned long Variant::cast<unsigned long>() const throw (TypeCastException) {
                        return (unsigned long) this->cast<uint64_t>();
                }

                template <> inline long Variant::cast<long>() const throw (TypeCastException) {
                        return (long) this->cast<int64_t>();
                }
#endif
        }
}

class sella::variant::Variant_iterator : public boost::iterator_facade<Variant_iterator, Variant, boost::forward_traversal_tag> {
        public:
                Variant_iterator() : it() { }
                Variant_iterator(const Variant_iterator &other) : it(other.it) { }
                Variant_iterator(const Variant_iterator &&other) : it(other.it) { }
                Variant_iterator(iterator_t it) : it(it) { }

                const std::string& key() const {
                        static const std::string empty;
                        if (it.type == Variant::IterObject) {
                                return it.oit->first;
                        }
                        return empty;
                }

                Variant& value() const { /* Alias for dereferencing iterator */
                        return dereference();
                }

        private:
                friend class boost::iterator_core_access;

                void increment() {
                        if (it.type == Variant::IterObject) {
                                ++it.oit;
                        } else if (it.type == Variant::IterVector) {
                                ++it.vit;
                        } else {
                                it.v = NULL;
                        }
                }

                bool equal(Variant_iterator const &other) const {
                        if (it.type != other.it.type) {
                                return false;
                        } else if (it.type == Variant::IterObject) {
                                return it.oit == other.it.oit;
                        } else if (it.type == Variant::IterVector) {
                                return it.vit == other.it.vit;
                        }

                        return it.v == other.it.v;
                }

                Variant& dereference() const {
                        if (it.type == Variant::IterObject) {
                                return it.oit->second;
                        } else if (it.type == Variant::IterVector) {
                                return *it.vit;
                        }

                        return *it.v;
                }

                iterator_t it;
};

#endif

/*
** vim: noet ts=3 sw=3
*/

---