/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
#include "qpid/types/Variant.h"
#include "qpid/log/Statement.h"
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <limits>
#include <sstream>

namespace qpid {
namespace types {

namespace {
const std::string EMPTY;
const std::string PREFIX("invalid conversion: ");
}

InvalidConversion::InvalidConversion(const std::string& msg) : Exception(PREFIX + msg) {}

class VariantImpl
{
  public:
    VariantImpl();
    VariantImpl(bool);
    VariantImpl(uint8_t);
    VariantImpl(uint16_t);
    VariantImpl(uint32_t);
    VariantImpl(uint64_t);
    VariantImpl(int8_t);
    VariantImpl(int16_t);
    VariantImpl(int32_t);
    VariantImpl(int64_t);
    VariantImpl(float);
    VariantImpl(double);
    VariantImpl(const std::string&, const std::string& encoding=std::string());
    VariantImpl(const Variant::Map&);
    VariantImpl(const Variant::List&);
    VariantImpl(const Uuid&);
    ~VariantImpl();

    VariantType getType() const;

    bool asBool() const;
    uint8_t asUint8() const;
    uint16_t asUint16() const;
    uint32_t asUint32() const;
    uint64_t asUint64() const;
    int8_t asInt8() const;
    int16_t asInt16() const;
    int32_t asInt32() const;
    int64_t asInt64() const;
    float asFloat() const;
    double asDouble() const;
    std::string asString() const;
    Uuid asUuid() const;

    const Variant::Map& asMap() const;
    Variant::Map& asMap();
    const Variant::List& asList() const;
    Variant::List& asList();

    const std::string& getString() const;
    std::string& getString();

    void setEncoding(const std::string&);
    const std::string& getEncoding() const;

    bool isEqualTo(VariantImpl&) const;
    bool isEquivalentTo(VariantImpl&) const;

    static VariantImpl* create(const Variant&);
  private:
    const VariantType type;
    union {
        bool b;
        uint8_t ui8;
        uint16_t ui16;
        uint32_t ui32;
        uint64_t ui64;
        int8_t i8;
        int16_t i16;
        int32_t i32;
        int64_t i64;
        float f;
        double d;
        void* v;//variable width data
    } value;
    std::string encoding;//optional encoding for variable length data

    template<class T> T convertFromString() const
    {
        std::string* s = reinterpret_cast<std::string*>(value.v);
        if (std::numeric_limits<T>::is_signed || s->find('-') != 0) {
            //lexical_cast won't fail if string is a negative number and T is unsigned
            try {
                return boost::lexical_cast<T>(*s);
            } catch(const boost::bad_lexical_cast&) {
                //don't return, throw exception below
            }
        } else {
            //T is unsigned and number starts with '-'
            try {
                //handle special case of negative zero
                if (boost::lexical_cast<int>(*s) == 0) return 0;
                //else its a non-zero negative number so throw exception at end of function
            } catch(const boost::bad_lexical_cast&) {
                //wasn't a valid int, therefore not a valid uint
            }
        }
        throw InvalidConversion(QPID_MSG("Cannot convert " << *s));
    }
};


VariantImpl::VariantImpl() : type(VAR_VOID) { value.i64 = 0; }
VariantImpl::VariantImpl(bool b) : type(VAR_BOOL) { value.b = b; }
VariantImpl::VariantImpl(uint8_t i) : type(VAR_UINT8) { value.ui8 = i; }
VariantImpl::VariantImpl(uint16_t i) : type(VAR_UINT16) { value.ui16 = i; }
VariantImpl::VariantImpl(uint32_t i) : type(VAR_UINT32) { value.ui32 = i; }
VariantImpl::VariantImpl(uint64_t i) : type(VAR_UINT64) { value.ui64 = i; }
VariantImpl::VariantImpl(int8_t i) : type(VAR_INT8) { value.i8 = i; }
VariantImpl::VariantImpl(int16_t i) : type(VAR_INT16) { value.i16 = i; }
VariantImpl::VariantImpl(int32_t i) : type(VAR_INT32) { value.i32 = i; }
VariantImpl::VariantImpl(int64_t i) : type(VAR_INT64) { value.i64 = i; }
VariantImpl::VariantImpl(float f) : type(VAR_FLOAT) { value.f = f; }
VariantImpl::VariantImpl(double d) : type(VAR_DOUBLE) { value.d = d; }
VariantImpl::VariantImpl(const std::string& s, const std::string& e)
    : type(VAR_STRING), encoding(e) { value.v = new std::string(s); }
VariantImpl::VariantImpl(const Variant::Map& m) : type(VAR_MAP) { value.v = new Variant::Map(m); }
VariantImpl::VariantImpl(const Variant::List& l) : type(VAR_LIST) { value.v = new Variant::List(l); }
VariantImpl::VariantImpl(const Uuid& u) : type(VAR_UUID) { value.v = new Uuid(u); }

VariantImpl::~VariantImpl() {
    switch (type) {
      case VAR_STRING:
        delete reinterpret_cast<std::string*>(value.v);
        break;
      case VAR_MAP:
        delete reinterpret_cast<Variant::Map*>(value.v);
        break;
      case VAR_LIST:
        delete reinterpret_cast<Variant::List*>(value.v);
        break;
      case VAR_UUID:
        delete reinterpret_cast<Uuid*>(value.v);
        break;
      default:
        break;
    }
}

VariantType VariantImpl::getType() const { return type; }

namespace {

bool same_char(char a, char b)
{
    return toupper(a) == toupper(b);
}

bool caseInsensitiveMatch(const std::string& a, const std::string& b)
{
    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), &same_char);
}

const std::string TRUE("True");
const std::string FALSE("False");

bool toBool(const std::string& s)
{
    if (caseInsensitiveMatch(s, TRUE)) return true;
    if (caseInsensitiveMatch(s, FALSE)) return false;
    try { return boost::lexical_cast<int>(s); } catch(const boost::bad_lexical_cast&) {}
    throw InvalidConversion(QPID_MSG("Cannot convert " << s << " to bool"));
}

template <class T> std::string toString(const T& t)
{
    std::stringstream out;
    out << t;
    return out.str();
}

template <class T> bool equal(const T& a, const T& b)
{
    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
}

}

bool VariantImpl::asBool() const
{
    switch(type) {
      case VAR_VOID: return false;
      case VAR_BOOL: return value.b;
      case VAR_UINT8: return value.ui8;
      case VAR_UINT16: return value.ui16;
      case VAR_UINT32: return value.ui32;
      case VAR_UINT64: return value.ui64;
      case VAR_INT8: return value.i8;
      case VAR_INT16: return value.i16;
      case VAR_INT32: return value.i32;
      case VAR_INT64: return value.i64;
      case VAR_STRING: return toBool(*reinterpret_cast<std::string*>(value.v));
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_BOOL)));
    }
}
uint8_t VariantImpl::asUint8() const
{
    switch(type) {
      case VAR_UINT8: return value.ui8;
      case VAR_UINT16:
          if (value.ui16 <= 0x00ff)
              return uint8_t(value.ui16);
          break;
      case VAR_UINT32:
          if (value.ui32 <= 0x000000ff)
              return uint8_t(value.ui32);
          break;
      case VAR_UINT64:
          if (value.ui64 <= 0x00000000000000ff)
              return uint8_t(value.ui64);
          break;
      case VAR_INT8:
          if (value.i8 >= 0)
              return uint8_t(value.i8);
          break;
      case VAR_INT16:
          if (value.i16 >= 0 && value.i16 <= 0x00ff)
              return uint8_t(value.i16);
          break;
      case VAR_INT32:
          if (value.i32 >= 0 && value.i32 <= 0x000000ff)
              return uint8_t(value.i32);
          break;
      case VAR_INT64:
          if (value.i64 >= 0 && value.i64 <= 0x00000000000000ff)
              return uint8_t(value.i64);
          break;
      case VAR_STRING: return convertFromString<uint8_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT8)));
}
uint16_t VariantImpl::asUint16() const
{
    switch(type) {
      case VAR_UINT8: return value.ui8;
      case VAR_UINT16: return value.ui16;
      case VAR_UINT32:
          if (value.ui32 <= 0x0000ffff)
              return uint16_t(value.ui32);
          break;
      case VAR_UINT64:
          if (value.ui64 <= 0x000000000000ffff)
              return uint16_t(value.ui64);
          break;
      case VAR_INT8:
          if (value.i8 >= 0)
              return uint16_t(value.i8);
          break;
      case VAR_INT16:
          if (value.i16 >= 0)
              return uint16_t(value.i16);
          break;
      case VAR_INT32:
          if (value.i32 >= 0 && value.i32 <= 0x0000ffff)
              return uint16_t(value.i32);
          break;
      case VAR_INT64:
          if (value.i64 >= 0 && value.i64 <= 0x000000000000ffff)
              return uint16_t(value.i64);
          break;
      case VAR_STRING: return convertFromString<uint16_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT16)));
}
uint32_t VariantImpl::asUint32() const
{
    switch(type) {
      case VAR_UINT8: return value.ui8;
      case VAR_UINT16: return value.ui16;
      case VAR_UINT32: return value.ui32;
      case VAR_UINT64:
          if (value.ui64 <= 0x00000000ffffffff)
              return uint32_t(value.ui64);
          break;
      case VAR_INT8:
          if (value.i8 >= 0)
              return uint32_t(value.i8);
          break;
      case VAR_INT16:
          if (value.i16 >= 0)
              return uint32_t(value.i16);
          break;
      case VAR_INT32:
          if (value.i32 >= 0)
              return uint32_t(value.i32);
          break;
      case VAR_INT64:
          if (value.i64 >= 0 && value.i64 <= 0x00000000ffffffff)
              return uint32_t(value.i64);
          break;
      case VAR_STRING: return convertFromString<uint32_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT32)));
}
uint64_t VariantImpl::asUint64() const
{
    switch(type) {
      case VAR_UINT8: return value.ui8;
      case VAR_UINT16: return value.ui16;
      case VAR_UINT32: return value.ui32;
      case VAR_UINT64: return value.ui64;
      case VAR_INT8:
          if (value.i8 >= 0)
              return uint64_t(value.i8);
          break;
      case VAR_INT16:
          if (value.i16 >= 0)
              return uint64_t(value.i16);
          break;
      case VAR_INT32:
          if (value.i32 >= 0)
              return uint64_t(value.i32);
          break;
      case VAR_INT64:
          if (value.i64 >= 0)
              return uint64_t(value.i64);
          break;
      case VAR_STRING: return convertFromString<uint64_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT64)));
}

int8_t VariantImpl::asInt8() const
{
    switch(type) {
      case VAR_INT8: return value.i8;
      case VAR_INT16:
          if ((value.i16 >= std::numeric_limits<int8_t>::min()) && (value.i16 <= std::numeric_limits<int8_t>::max()))
              return int8_t(value.i16);
          break;
      case VAR_INT32:
          if ((value.i32 >= std::numeric_limits<int8_t>::min()) && (value.i32 <= std::numeric_limits<int8_t>::max()))
              return int8_t(value.i32);
          break;
      case VAR_INT64:
          if ((value.i64 >= std::numeric_limits<int8_t>::min()) && (value.i64 <= std::numeric_limits<int8_t>::max()))
              return int8_t(value.i64);
          break;
      case VAR_UINT8:
          if (value.ui8 <= std::numeric_limits<int8_t>::max())
              return int8_t(value.ui8);
          break;
      case VAR_UINT16:
          if (value.ui16 <= std::numeric_limits<int8_t>::max())
              return int8_t(value.ui16);
          break;
      case VAR_UINT32:
          if (value.ui32 <= (uint32_t) std::numeric_limits<int8_t>::max())
              return int8_t(value.ui32);
          break;
      case VAR_UINT64:
          if (value.ui64 <= (uint64_t) std::numeric_limits<int8_t>::max())
              return int8_t(value.ui64);
          break;
      case VAR_STRING: return convertFromString<int8_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT8)));
}
int16_t VariantImpl::asInt16() const
{
    switch(type) {
      case VAR_INT8: return value.i8;
      case VAR_INT16: return value.i16;
      case VAR_INT32:
          if ((value.i32 >= std::numeric_limits<int16_t>::min()) && (value.i32 <= std::numeric_limits<int16_t>::max()))
              return int16_t(value.i32);
          break;
      case VAR_INT64:
          if ((value.i64 >= std::numeric_limits<int16_t>::min()) && (value.i64 <= std::numeric_limits<int16_t>::max()))
              return int16_t(value.i64);
          break;
      case VAR_UINT8:  return int16_t(value.ui8);
      case VAR_UINT16:
          if (value.ui16 <= std::numeric_limits<int16_t>::max())
              return int16_t(value.ui16);
          break;
      case VAR_UINT32:
          if (value.ui32 <= (uint32_t) std::numeric_limits<int16_t>::max())
              return int16_t(value.ui32);
          break;
      case VAR_UINT64:
          if (value.ui64 <= (uint64_t) std::numeric_limits<int16_t>::max())
              return int16_t(value.ui64);
          break;
      case VAR_STRING: return convertFromString<int16_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT16)));
}
int32_t VariantImpl::asInt32() const
{
    switch(type) {
      case VAR_INT8: return value.i8;
      case VAR_INT16: return value.i16;
      case VAR_INT32: return value.i32;
      case VAR_INT64:
          if ((value.i64 >= std::numeric_limits<int32_t>::min()) && (value.i64 <= std::numeric_limits<int32_t>::max()))
              return int32_t(value.i64);
          break;
      case VAR_UINT8:  return int32_t(value.ui8);
      case VAR_UINT16: return int32_t(value.ui16);
      case VAR_UINT32:
        if (value.ui32 <= (uint32_t) std::numeric_limits<int32_t>::max())
              return int32_t(value.ui32);
          break;
      case VAR_UINT64:
        if (value.ui64 <= (uint64_t) std::numeric_limits<int32_t>::max())
              return int32_t(value.ui64);
          break;
      case VAR_STRING: return convertFromString<int32_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT32)));
}
int64_t VariantImpl::asInt64() const
{
    switch(type) {
      case VAR_INT8: return value.i8;
      case VAR_INT16: return value.i16;
      case VAR_INT32: return value.i32;
      case VAR_INT64: return value.i64;
      case VAR_UINT8: return int64_t(value.ui8);
      case VAR_UINT16: return int64_t(value.ui16);
      case VAR_UINT32: return int64_t(value.ui32);
      case VAR_UINT64:
        if (value.ui64 <= (uint64_t) std::numeric_limits<int64_t>::max())
              return int64_t(value.ui64);
          break;
      case VAR_STRING: return convertFromString<int64_t>();
      default: break;
    }
    throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT64)));
}
float VariantImpl::asFloat() const
{
    switch(type) {
      case VAR_FLOAT: return value.f;
      case VAR_STRING: return convertFromString<float>();
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_FLOAT)));
    }
}
double VariantImpl::asDouble() const
{
    switch(type) {
      case VAR_FLOAT: return value.f;
      case VAR_DOUBLE: return value.d;
      case VAR_STRING: return convertFromString<double>();
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_DOUBLE)));
    }
}
std::string VariantImpl::asString() const
{
    switch(type) {
      case VAR_VOID: return EMPTY;
      case VAR_BOOL: return value.b ? TRUE : FALSE;
      case VAR_UINT8: return boost::lexical_cast<std::string>((int) value.ui8);
      case VAR_UINT16: return boost::lexical_cast<std::string>(value.ui16);
      case VAR_UINT32: return boost::lexical_cast<std::string>(value.ui32);
      case VAR_UINT64: return boost::lexical_cast<std::string>(value.ui64);
      case VAR_INT8: return boost::lexical_cast<std::string>((int) value.i8);
      case VAR_INT16: return boost::lexical_cast<std::string>(value.i16);
      case VAR_INT32: return boost::lexical_cast<std::string>(value.i32);
      case VAR_INT64: return boost::lexical_cast<std::string>(value.i64);
      case VAR_DOUBLE: return boost::lexical_cast<std::string>(value.d);
      case VAR_FLOAT: return boost::lexical_cast<std::string>(value.f);
      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
      case VAR_UUID: return reinterpret_cast<Uuid*>(value.v)->str();
      case VAR_LIST: return toString(asList());
      case VAR_MAP: return toString(asMap());
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_STRING)));
    }
}
Uuid VariantImpl::asUuid() const
{
    switch(type) {
      case VAR_UUID: return *reinterpret_cast<Uuid*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UUID)));
    }
}

bool VariantImpl::isEqualTo(VariantImpl& other) const
{
    if (type == other.type) {
        switch(type) {
          case VAR_VOID: return true;
          case VAR_BOOL: return value.b == other.value.b;
          case VAR_UINT8: return value.ui8 == other.value.ui8;
          case VAR_UINT16: return value.ui16 == other.value.ui16;
          case VAR_UINT32: return value.ui32 == other.value.ui32;
          case VAR_UINT64: return value.ui64 == other.value.ui64;
          case VAR_INT8: return value.i8 == other.value.i8;
          case VAR_INT16: return value.i16 == other.value.i16;
          case VAR_INT32: return value.i32 == other.value.i32;
          case VAR_INT64: return value.i64 == other.value.i64;
          case VAR_DOUBLE: return value.d == other.value.d;
          case VAR_FLOAT: return value.f == other.value.f;
          case VAR_STRING: return *reinterpret_cast<std::string*>(value.v)
                == *reinterpret_cast<std::string*>(other.value.v);
          case VAR_UUID: return *reinterpret_cast<Uuid*>(value.v)
                == *reinterpret_cast<Uuid*>(other.value.v);
          case VAR_LIST: return equal(asList(), other.asList());
          case VAR_MAP: return equal(asMap(), other.asMap());
        }
    }
    return false;
}

const Variant::Map& VariantImpl::asMap() const
{
    switch(type) {
      case VAR_MAP: return *reinterpret_cast<Variant::Map*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_MAP)));
    }
}

Variant::Map& VariantImpl::asMap()
{
    switch(type) {
      case VAR_MAP: return *reinterpret_cast<Variant::Map*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_MAP)));
    }
}

const Variant::List& VariantImpl::asList() const
{
    switch(type) {
      case VAR_LIST: return *reinterpret_cast<Variant::List*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_LIST)));
    }
}

Variant::List& VariantImpl::asList()
{
    switch(type) {
      case VAR_LIST: return *reinterpret_cast<Variant::List*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_LIST)));
    }
}

std::string& VariantImpl::getString()
{
    switch(type) {
      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Variant is not a string; use asString() if conversion is required."));
    }
}

const std::string& VariantImpl::getString() const
{
    switch(type) {
      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
      default: throw InvalidConversion(QPID_MSG("Variant is not a string; use asString() if conversion is required."));
    }
}

void VariantImpl::setEncoding(const std::string& s) { encoding = s; }
const std::string& VariantImpl::getEncoding() const { return encoding; }

std::string getTypeName(VariantType type)
{
    switch (type) {
      case VAR_VOID: return "void";
      case VAR_BOOL: return "bool";
      case VAR_UINT8: return "uint8";
      case VAR_UINT16: return "uint16";
      case VAR_UINT32: return "uint32";
      case VAR_UINT64: return "uint64";
      case VAR_INT8: return "int8";
      case VAR_INT16: return "int16";
      case VAR_INT32: return "int32";
      case VAR_INT64: return "int64";
      case VAR_FLOAT: return "float";
      case VAR_DOUBLE: return "double";
      case VAR_STRING: return "string";
      case VAR_MAP: return "map";
      case VAR_LIST: return "list";
      case VAR_UUID: return "uuid";
    }
    return "<unknown>";//should never happen
}

bool isIntegerType(VariantType type)
{
    switch (type) {
      case VAR_BOOL:
      case VAR_UINT8:
      case VAR_UINT16:
      case VAR_UINT32:
      case VAR_UINT64:
      case VAR_INT8:
      case VAR_INT16:
      case VAR_INT32:
      case VAR_INT64:
        return true;
      default:
        return false;
    }
}

VariantImpl* VariantImpl::create(const Variant& v)
{
    switch (v.getType()) {
      case VAR_BOOL: return new VariantImpl(v.asBool());
      case VAR_UINT8: return new VariantImpl(v.asUint8());
      case VAR_UINT16: return new VariantImpl(v.asUint16());
      case VAR_UINT32: return new VariantImpl(v.asUint32());
      case VAR_UINT64: return new VariantImpl(v.asUint64());
      case VAR_INT8: return new VariantImpl(v.asInt8());
      case VAR_INT16: return new VariantImpl(v.asInt16());
      case VAR_INT32: return new VariantImpl(v.asInt32());
      case VAR_INT64: return new VariantImpl(v.asInt64());
      case VAR_FLOAT: return new VariantImpl(v.asFloat());
      case VAR_DOUBLE: return new VariantImpl(v.asDouble());
      case VAR_STRING: return new VariantImpl(v.asString(), v.getEncoding());
      case VAR_MAP: return new VariantImpl(v.asMap());
      case VAR_LIST: return new VariantImpl(v.asList());
      case VAR_UUID: return new VariantImpl(v.asUuid());
      default: return new VariantImpl();
    }
}

Variant::Variant() : impl(0) {}
Variant::Variant(bool b) : impl(new VariantImpl(b)) {}
Variant::Variant(uint8_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(uint16_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(uint32_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(uint64_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(int8_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(int16_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(int32_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(int64_t i) : impl(new VariantImpl(i)) {}
Variant::Variant(float f) : impl(new VariantImpl(f)) {}
Variant::Variant(double d) : impl(new VariantImpl(d)) {}
Variant::Variant(const std::string& s) : impl(new VariantImpl(s)) {}
Variant::Variant(const char* s) : impl(new VariantImpl(std::string(s))) {}
Variant::Variant(const Map& m) : impl(new VariantImpl(m)) {}
Variant::Variant(const List& l) : impl(new VariantImpl(l)) {}
Variant::Variant(const Variant& v) : impl(VariantImpl::create(v)) {}
Variant::Variant(const Uuid& u) : impl(new VariantImpl(u)) {}

Variant::~Variant() { if (impl) delete impl; }

void Variant::reset()
{
    if (impl) delete impl;
    impl = 0;
}


Variant& Variant::operator=(bool b)
{
    if (impl) delete impl;
    impl = new VariantImpl(b);
    return *this;
}

Variant& Variant::operator=(uint8_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(uint16_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(uint32_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(uint64_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}

Variant& Variant::operator=(int8_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(int16_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(int32_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}
Variant& Variant::operator=(int64_t i)
{
    if (impl) delete impl;
    impl = new VariantImpl(i);
    return *this;
}

Variant& Variant::operator=(float f)
{
    if (impl) delete impl;
    impl = new VariantImpl(f);
    return *this;
}
Variant& Variant::operator=(double d)
{
    if (impl) delete impl;
    impl = new VariantImpl(d);
    return *this;
}

Variant& Variant::operator=(const std::string& s)
{
    if (impl) delete impl;
    impl = new VariantImpl(s);
    return *this;
}

Variant& Variant::operator=(const char* s)
{
    if (impl) delete impl;
    impl = new VariantImpl(std::string(s));
    return *this;
}

Variant& Variant::operator=(const Uuid& u)
{
    if (impl) delete impl;
    impl = new VariantImpl(u);
    return *this;
}

Variant& Variant::operator=(const Map& m)
{
    if (impl) delete impl;
    impl = new VariantImpl(m);
    return *this;
}

Variant& Variant::operator=(const List& l)
{
    if (impl) delete impl;
    impl = new VariantImpl(l);
    return *this;
}

Variant& Variant::operator=(const Variant& v)
{
    if (impl) delete impl;
    impl = VariantImpl::create(v);
    return *this;
}

Variant& Variant::parse(const std::string& s)
{
    operator=(s);
    try {
        return operator=(asInt64());
    } catch (const InvalidConversion&) {}
    try {
        return operator=(asDouble());
    } catch (const InvalidConversion&) {}
    try {
        return operator=(asBool());
    } catch (const InvalidConversion&) {}
    return *this;
}


VariantType Variant::getType() const { return impl ? impl->getType() : VAR_VOID; }
bool Variant::isVoid() const { return getType() == VAR_VOID; }
bool Variant::asBool() const { return impl && impl->asBool(); }
uint8_t Variant::asUint8() const { return impl ? impl->asUint8() : 0; }
uint16_t Variant::asUint16() const { return impl ? impl->asUint16() : 0; }
uint32_t Variant::asUint32() const { return impl ? impl->asUint32() : 0; }
uint64_t Variant::asUint64() const { return impl ? impl->asUint64() : 0; }
int8_t Variant::asInt8() const { return impl ? impl->asInt8() : 0; }
int16_t Variant::asInt16() const { return impl ? impl->asInt16() : 0; }
int32_t Variant::asInt32() const { return impl ? impl->asInt32(): 0; }
int64_t Variant::asInt64() const { return impl ? impl->asInt64() : 0; }
float Variant::asFloat() const { return impl ? impl->asFloat() : 0; }
double Variant::asDouble() const { return impl ? impl->asDouble() : 0; }
std::string Variant::asString() const { return impl ? impl->asString() : EMPTY; }
Uuid Variant::asUuid() const { return impl ? impl->asUuid() : Uuid(); }
const Variant::Map& Variant::asMap() const { if (!impl) throw InvalidConversion("Can't convert VOID to MAP"); return impl->asMap(); }
Variant::Map& Variant::asMap() { if (!impl) throw InvalidConversion("Can't convert VOID to MAP"); return impl->asMap(); }
const Variant::List& Variant::asList() const { if (!impl) throw InvalidConversion("Can't convert VOID to LIST"); return impl->asList(); }
Variant::List& Variant::asList() { if (!impl) throw InvalidConversion("Can't convert VOID to LIST"); return impl->asList(); }
const std::string& Variant::getString() const { if (!impl) throw InvalidConversion("Can't convert VOID to STRING"); return impl->getString(); }
std::string& Variant::getString() { if (!impl) throw InvalidConversion("Can't convert VOID to STRING"); return impl->getString(); }
void Variant::setEncoding(const std::string& s) {
    if (!impl) impl = new VariantImpl();
    impl->setEncoding(s);
}
const std::string& Variant::getEncoding() const { return impl ? impl->getEncoding() : EMPTY; }

Variant::operator bool() const { return asBool(); }
Variant::operator uint8_t() const { return asUint8(); }
Variant::operator uint16_t() const { return asUint16(); }
Variant::operator uint32_t() const { return asUint32(); }
Variant::operator uint64_t() const { return asUint64(); }
Variant::operator int8_t() const { return asInt8(); }
Variant::operator int16_t() const { return asInt16(); }
Variant::operator int32_t() const { return asInt32(); }
Variant::operator int64_t() const { return asInt64(); }
Variant::operator float() const { return asFloat(); }
Variant::operator double() const { return asDouble(); }
Variant::operator std::string() const { return asString(); }
Variant::operator Uuid() const { return asUuid(); }

std::ostream& operator<<(std::ostream& out, const Variant::Map& map)
{
    out << "{";
    for (Variant::Map::const_iterator i = map.begin(); i != map.end(); ++i) {
        if (i != map.begin()) out << ", ";
        out << i->first << ":" << i->second;
    }
    out << "}";
    return out;
}

std::ostream& operator<<(std::ostream& out, const Variant::List& list)
{
    out << "[";
    for (Variant::List::const_iterator i = list.begin(); i != list.end(); ++i) {
        if (i != list.begin()) out << ", ";
        out << *i;
    }
    out << "]";
    return out;
}

std::ostream& operator<<(std::ostream& out, const Variant& value)
{
    switch (value.getType()) {
      case VAR_MAP:
        out << value.asMap();
        break;
      case VAR_LIST:
        out << value.asList();
        break;
      case VAR_VOID:
        out << "<void>";
        break;
      default:
        out << value.asString();
        break;
    }
    return out;
}

bool operator==(const Variant& a, const Variant& b)
{
    return a.isEqualTo(b);
}

bool Variant::isEqualTo(const Variant& other) const
{
    return impl && impl->isEqualTo(*other.impl);
}

}} // namespace qpid::types
