variant.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2016, 2018, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_VARIANT_HPP
#define CPPWAMP_VARIANT_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <algorithm>
#include <cstdint>
#include <map>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "api.hpp"
#include "blob.hpp"
#include "conversionaccess.hpp"
#include "error.hpp"
#include "null.hpp"
#include "traits.hpp"
#include "variantdefs.hpp"
#include "visitor.hpp"
#include "internal/varianttraits.hpp"
#include "internal/variantvisitors.hpp"
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define CPPWAMP_CONVERSION_SPLIT_FREE(Type)                     \
inline void convert(::wamp::FromVariantConverter& c, Type& obj) \
{                                                               \
    convertFrom(c, obj);                                        \
}                                                               \
                                                                \
inline void convert(::wamp::ToVariantConverter& c, Type& obj)   \
{                                                               \
    convertTo(c, const_cast<const Type&>(obj));                 \
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define CPPWAMP_CONVERSION_SPLIT_MEMBER(Type)                   \
inline void convert(::wamp::FromVariantConverter& c, Type& obj) \
{                                                               \
    wamp::ConversionAccess::convertFrom(c, obj);                \
}                                                               \
                                                                \
inline void convert(::wamp::ToVariantConverter& c, Type& obj)   \
{                                                               \
    const auto& constObj = obj;                                 \
    wamp::ConversionAccess::convertTo(c, constObj);             \
}
 
 
namespace wamp
{
 
//------------------------------------------------------------------------------
// Forward declaration
namespace internal {template <TypeId typeId> struct FieldTypeForId;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Variant
{
private:
    template <typename TField, typename Enable = void>
    using ArgTraits = internal::ArgTraits<TField>;
 
public:
 
    template <TypeId typeId>
    using BoundTypeForId = typename internal::FieldTypeForId<typeId>::Type;
 
    template <typename T>
    static constexpr bool isValidArg() noexcept
    {
        return ArgTraits<ValueTypeOf<T>>::isValid;
    }
 
    /* Indicates that the given argument type is not convertible
       to a bound type. */
    template <typename T>
    static constexpr bool isInvalidArg() noexcept
    {
        return !ArgTraits<ValueTypeOf<T>>::isValid &&
               !isSameType<T, Variant>();
    }
 
    /* Indicates that the given argument type is a Variant. */
    template <typename T>
    static constexpr bool isVariantArg() noexcept
    {
        return isSameType<ValueTypeOf<T>, Variant>();
    }
 
 
    using Null   = wamp::Null;   
    using Bool   = wamp::Bool;   
    using Int    = wamp::Int;    
    using UInt   = wamp::UInt;   
    using Real   = wamp::Real;   
    using String = wamp::String; 
    using Blob   = wamp::Blob;   
    using Array  = wamp::Array;  
    using Object = wamp::Object; 
 
    using SizeType = Array::size_type;
 
    using CharType = String::value_type;
 
 
    template <typename TValue>
    static Variant from(TValue&& value);
 
    Variant() noexcept;
 
    Variant(const Variant& other);
 
    Variant(Variant&& other) noexcept;
 
    template <typename T, CPPWAMP_ENABLE_IF(Variant::isValidArg<T>()) = 0>
    Variant(T value);
 
    Variant(Array array);
 
    template <typename T> Variant(std::vector<T> vec);
 
    Variant(Object object);
 
    template <typename T> Variant(std::map<String, T> map);
 
    ~Variant();
 
 
 
    TypeId typeId() const;
 
    explicit operator bool() const;
 
    template <typename TBound> bool is() const;
 
    template <TypeId id> bool is() const;
 
    template <typename T> T to() const;
 
    template <typename T> void to(T& value) const;
 
    template <typename T>
    ValueTypeOf<T> valueOr(T&& fallback) const;
 
    SizeType size() const;
 
 
 
    template <typename TBound> TBound& as();
 
    template <typename TBound> const TBound& as() const;
 
    template <TypeId id> BoundTypeForId<id>& as();
 
    template <TypeId id> const BoundTypeForId<id>& as() const;
 
    Variant& operator[](SizeType index);
 
    const Variant& operator[](SizeType index) const;
 
    Variant& at(SizeType index);
 
    const Variant& at(SizeType index) const;
 
    Variant& operator[](const String& key);
 
    Variant& at(const String& key);
 
    const Variant& at(const String& key) const;
 
 
 
    bool operator==(const Variant& other) const;
 
    bool operator!=(const Variant& other) const;
 
    bool operator<(const Variant& other) const;
 
 
 
    Variant& operator=(const Variant& other);
 
    Variant& operator=(Variant&& other) noexcept;
 
    template <typename T> Variant& operator=(T value);
 
    Variant& operator=(Array array);
 
    template <typename T> Variant& operator=(std::vector<T> vec);
 
    Variant& operator=(Object object);
 
    template <typename T> Variant& operator=(std::map<String, T> map);
 
    void swap(Variant& other) noexcept;
 
 
private:
    class CPPWAMP_HIDDEN Construct;
    class CPPWAMP_HIDDEN MoveConstruct;
    class CPPWAMP_HIDDEN MoveAssign;
    class CPPWAMP_HIDDEN Destruct;
    class CPPWAMP_HIDDEN Swap;
    class CPPWAMP_HIDDEN ElementCount;
    class CPPWAMP_HIDDEN LessThan;
    class CPPWAMP_HIDDEN Output;
 
    template <typename TField>
    using FieldTraits = internal::FieldTraits<TField>;
 
    template <typename TField>
    using Access = internal::Access<TField>;
 
    template <typename... TFields> struct CPPWAMP_HIDDEN TypeMask;
 
    template <TypeId... typeIds> struct CPPWAMP_HIDDEN TypeIdMask;
 
    template <typename TValue, typename TArg>
    CPPWAMP_HIDDEN void constructAs(TArg&& value);
 
    template <typename TField>
    CPPWAMP_HIDDEN void destructAs();
 
    // Can't be hidden; invoked from inline operator=(T)
    void destruct();
 
    template <typename T, EnableIf<Variant::isValidArg<T>()> = 0>
    CPPWAMP_HIDDEN static Variant convertFrom(T&& value);
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN static Variant convertFrom(const T& value);
 
    template <typename T, EnableIf<Variant::isVariantArg<T>()> = 0>
    CPPWAMP_HIDDEN static Variant convertFrom(const T& variant);
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN static Variant convertFrom(const std::vector<T>& vec);
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN static Variant convertFrom(const std::map<String, T>& map);
 
    template <typename T, EnableIf<Variant::isValidArg<T>()> = 0>
    CPPWAMP_HIDDEN void convertTo(T& value) const;
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN void convertTo(T& value) const;
 
    template <typename T, EnableIf<Variant::isVariantArg<T>()> = 0>
    CPPWAMP_HIDDEN void convertTo(T& variant) const;
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN void convertTo(std::vector<T>& vec) const;
 
    template <typename T, EnableIf<Variant::isInvalidArg<T>()> = 0>
    CPPWAMP_HIDDEN void convertTo(std::map<String, T>& map) const;
 
    template <typename TField, typename V>
    CPPWAMP_HIDDEN static TField& get(V&& variant);
 
    union Field
    {
        Field();
        ~Field();
        Null    nullValue;
        Bool    boolean;
        Int     integer;
        UInt    uint;
        Real    real;
        String  string;
        Blob*   blob;
        Array*  array;
        Object* object;
    } field_;
 
    TypeId typeId_;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
CPPWAMP_API void swap(Variant& v, Variant& w) noexcept;
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
CPPWAMP_API bool isNumber(const Variant& v);
 
CPPWAMP_API bool isScalar(const Variant& v);
 
CPPWAMP_API Variant::String typeNameOf(const Variant& v);
 
template <typename TBound>
CPPWAMP_API Variant::String typeNameOf();
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Array& a);
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Object& o);
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Variant& v);
 
CPPWAMP_API std::string toString(const Array& a);
 
CPPWAMP_API std::string toString(const Object& o);
 
CPPWAMP_API std::string toString(const Variant& v);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
template <typename T>
CPPWAMP_API bool operator==(const Variant& variant, const T& value);
 
template <typename T>
CPPWAMP_API bool operator==(const T& value, const Variant& variant);
 
CPPWAMP_API bool operator==(const Variant& variant,
                            const Variant::CharType* str);
 
CPPWAMP_API bool operator==(const Variant::CharType* str,
                            const Variant& variant);
 
CPPWAMP_API bool operator==(const Variant& variant, Variant::CharType* str);
 
CPPWAMP_API bool operator==(Variant::CharType* str, const Variant& variant);
 
template <typename T>
bool operator!=(const Variant& variant, const T& value);
 
template <typename T>
CPPWAMP_API bool operator!=(const T& value, const Variant& variant);
 
CPPWAMP_API bool operator!=(const Variant& variant,
                            const Variant::CharType* str);
 
CPPWAMP_API bool operator!=(const Variant::CharType* str,
                            const Variant& variant);
 
CPPWAMP_API bool operator!=(const Variant& variant, Variant::CharType* str);
 
CPPWAMP_API bool operator!=(Variant::CharType* str, const Variant& variant);
 
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API ToVariantConverter
{
public:
    using SizeType = size_t;
 
    using String = std::string;
 
    static constexpr bool convertingToVariant = true;
 
    explicit ToVariantConverter(Variant& var);
 
    ToVariantConverter& size(SizeType n);
 
    template <typename T>
    ToVariantConverter& operator()(T&& value);
 
    template <typename T>
    ToVariantConverter& operator[](T&& value);
 
    template <typename T>
    ToVariantConverter& operator()(String key, T&& value);
 
    template <typename T, typename U>
    ToVariantConverter& operator()(String key, T&& value, U&& ignored);
 
    Variant& variant();
 
private:
    Variant& var_;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API FromVariantConverter
{
public:
    using SizeType = size_t;
 
    using String = std::string;
 
    static constexpr bool convertingToVariant = false;
 
    explicit FromVariantConverter(const Variant& var);
 
    SizeType size() const;
 
    FromVariantConverter& size(SizeType& n);
 
    template <typename T>
    FromVariantConverter& operator()(T& value);
 
    template <typename T>
    FromVariantConverter& operator[](T& value);
 
    template <typename T>
    FromVariantConverter& operator()(const String& key, T& value);
 
    template <typename T, typename U>
    FromVariantConverter& operator()(const String& key, T& value, U&& fallback);
 
    const Variant& variant() const;
 
private:
    const Variant& var_;
    SizeType index_ = 0;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TConverter, typename TValue,
         DisableIf<std::is_enum<TValue>::value> = 0>
CPPWAMP_API inline void convert(TConverter& c, TValue& val)
{
    // Fall back to intrusive conversion if 'convert' was not specialized
    // for the given type.
    ConversionAccess::convert(c, val);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TEnum, EnableIf<std::is_enum<TEnum>::value> = 0>
CPPWAMP_API inline void convert(const FromVariantConverter& c, TEnum& e)
{
    using U = typename std::underlying_type<TEnum>::type;
    auto n = c.variant().to<U>();
    e = static_cast<TEnum>(n);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TEnum, EnableIf<std::is_enum<TEnum>::value> = 0>
CPPWAMP_API inline void convert(ToVariantConverter& c, const TEnum& e)
{
    using U = typename std::underlying_type<TEnum>::type;
    c.variant() = static_cast<U>(e);
}
 
 
//******************************************************************************
// Variant template member function implementations
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename TValue>
Variant Variant::from(TValue&& value)
{
    return convertFrom(std::forward<TValue>(value));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, CPPWAMP_ENABLE_IF(Variant::isValidArg<T>())>
Variant::Variant(T value)
{
    static_assert(ArgTraits<T>::isValid, "Invalid argument type");
    using FieldType = typename ArgTraits<T>::FieldType;
    typeId_ = FieldTraits<FieldType>::typeId;
    constructAs<FieldType>(std::move(value));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> Variant::Variant(std::vector<T> vec)
    : typeId_(TypeId::array)
{
    static_assert(ArgTraits<T>::isValid, "Invalid vector element type");
    Array array;
    array.reserve(vec.size());
    std::move(vec.begin(), vec.end(), std::back_inserter(array));
    constructAs<Array>(std::move(array));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> Variant::Variant(std::map<String, T> map)
    : typeId_(TypeId::object)
{
    static_assert(ArgTraits<T>::isValid, "Invalid map value type");
    Object object;
    std::move(map.begin(), map.end(), std::inserter(object, object.begin()));
    constructAs<Object>(std::move(object));
}
 
//------------------------------------------------------------------------------
template <typename TBound> bool Variant::is() const
{
    static_assert(FieldTraits<TBound>::isValid, "Invalid field type");
    return typeId_ == FieldTraits<TBound>::typeId;
}
 
//------------------------------------------------------------------------------
template <TypeId id> bool Variant::is() const
{
    return is<BoundTypeForId<id>>();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> T Variant::to() const
{
    T result(std::move(ConversionAccess::defaultConstruct<T>()));
    convertTo(result);
    return result;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> void Variant::to(T& value) const
{
    convertTo(value);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
ValueTypeOf<T> Variant::valueOr(T&& fallback) const
{
    if (!*this)
        return std::forward<T>(fallback);
    else
        return this->to< ValueTypeOf<T> >();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TBound> TBound& Variant::as()
{
    return get<TBound>(*this);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TBound> const TBound& Variant::as() const
{
    return get<const TBound>(*this);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <TypeId id>
Variant::BoundTypeForId<id>& Variant::as()
{
    return as<BoundTypeForId<id>>();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <TypeId id>
const Variant::BoundTypeForId<id>& Variant::as() const
{
    return as<BoundTypeForId<id>>();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> Variant& Variant::operator=(T value)
{
    static_assert(ArgTraits<T>::isValid, "Invalid argument type");
 
    using FieldType = typename ArgTraits<T>::FieldType;
    if (is<FieldType>())
        as<FieldType>() = std::move(value);
    else
    {
        destruct();
        constructAs<FieldType>(std::move(value));
        typeId_ = FieldTraits<FieldType>::typeId;
    }
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
Variant& Variant::operator=(std::vector<T> vec)
{
    static_assert(ArgTraits<T>::isValid, "Invalid vector element type");
 
    Array array;
    array.reserve(vec.size());
    std::move(vec.begin(), vec.end(), std::back_inserter(array));
    return *this = std::move(array);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
Variant& Variant::operator=(std::map<String,T> map)
{
    static_assert(ArgTraits<T>::isValid, "Invalid map value type");
    Object object(map.cbegin(), map.cend());
    return *this = std::move(object);
}
 
//------------------------------------------------------------------------------
template <typename TField, typename TArg>
void Variant::constructAs(TArg&& value)
{
    Access<TField>::construct(std::forward<TArg>(value), &field_);
}
 
//------------------------------------------------------------------------------
template <typename TField> void Variant::destructAs()
{
    Access<TField>::destruct(&field_);
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isValidArg<T>()>>
Variant Variant::convertFrom(T&& value)
{
    return Variant(std::forward<T>(value));
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
Variant Variant::convertFrom(const T& value)
{
    Variant v;
    ToVariantConverter conv(v);
    convert(conv, const_cast<T&>(value));
    return v;
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isVariantArg<T>()>>
Variant Variant::convertFrom(const T& variant)
{
    return variant;
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
Variant Variant::convertFrom(const std::vector<T>& vec)
{
    Variant::Array array;
    for (const auto& elem: vec)
        array.emplace_back(Variant::convertFrom(elem));
    return Variant(std::move(array));
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
Variant Variant::convertFrom(const std::map<String, T>& map)
{
    Variant::Object object;
    for (const auto& kv: map)
        object.emplace(kv.first, Variant::convertFrom(kv.second));
    return Variant(std::move(object));
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isValidArg<T>()>>
void Variant::convertTo(T& value) const
{
    applyWithOperand(internal::VariantConvertTo<Variant>(), *this, value);
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
void Variant::convertTo(T& value) const
{
    FromVariantConverter conv(*this);
    convert(conv, value);
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isVariantArg<T>()>>
void Variant::convertTo(T& variant) const
{
    variant = *this;
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
void Variant::convertTo(std::vector<T>& vec) const
{
    const auto& array = this->as<Array>();
    for (const auto& elem: array)
    {
        T value;
        elem.convertTo(value);
        vec.emplace_back(std::move(value));
    }
}
 
//------------------------------------------------------------------------------
template <typename T, EnableIf<Variant::isInvalidArg<T>()>>
void Variant::convertTo(std::map<String, T>& map) const
{
    const auto& object = this->as<Object>();
    for (const auto& kv: object)
    {
        T value;
        kv.second.convertTo(value);
        map.emplace(std::move(kv.first), std::move(value));
    }
}
 
//------------------------------------------------------------------------------
template <typename TField, typename V> TField& Variant::get(V&& variant)
{
    using FieldType = typename std::remove_const<TField>::type;
    static_assert(FieldTraits<FieldType>::isValid, "Invalid field type");
    if (!variant.template is<FieldType>())
        throw error::Access(wamp::typeNameOf(variant),
                            FieldTraits<FieldType>::typeName());
    return Access<FieldType>::get(&variant.field_);
}
 
//------------------------------------------------------------------------------
template <typename TBound>
Variant::String typeNameOf()
{
    return internal::FieldTraits<TBound>::typeName();
}
 
//------------------------------------------------------------------------------
template <typename T>
bool operator==(const Variant& variant, const T& value)
{
    static_assert(internal::ArgTraits<T>::isValid,
                  "Invalid value type");
    return applyWithOperand(internal::VariantEquivalentTo<Variant>(), variant,
                            value);
}
 
//------------------------------------------------------------------------------
template <typename T>
bool operator==(const T& value, const Variant& variant)
{
    return variant == value;
}
 
//------------------------------------------------------------------------------
template <typename T>
bool operator!=(const Variant& variant, const T& value)
{
    static_assert(internal::ArgTraits<T>::isValid,
                  "Invalid value type");
    return applyWithOperand(internal::VariantNotEquivalentTo<Variant>(),
                            variant, value);
}
 
//------------------------------------------------------------------------------
template <typename T>
bool operator!=(const T& value, const Variant& variant)
{
    return variant != value;
}
 
 
//******************************************************************************
// ToVariantConverter implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
inline ToVariantConverter::ToVariantConverter(Variant& var) : var_(var) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
inline ToVariantConverter& ToVariantConverter::size(SizeType n)
{
    Array array;
    array.reserve(n);
    var_ = std::move(array);
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
ToVariantConverter& ToVariantConverter::operator()(T&& value)
{
    var_ = Variant::from(std::forward<T>(value));
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
ToVariantConverter& ToVariantConverter::operator[](T&& value)
{
    if (!var_.is<Array>())
        var_ = Array();
    auto& array = var_.as<Array>();
    array.emplace_back(Variant::from(std::forward<T>(value)));
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
ToVariantConverter& ToVariantConverter::operator()(String key, T&& value)
{
    if (!var_.is<Object>())
        var_ = Object();
    auto& object = var_.as<Object>();
    object.emplace( std::move(key),
                   Variant::from(std::forward<T>(value)) );
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename U>
ToVariantConverter& ToVariantConverter::operator()(String key, T&& value, U&&)
{
    return operator()(std::move(key), std::forward<T>(value));
}
 
inline Variant& ToVariantConverter::variant() {return var_;}
 
 
//******************************************************************************
// FromVariantConverter implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
inline FromVariantConverter::FromVariantConverter(const Variant& var)
    : var_(var)
{}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
inline FromVariantConverter::SizeType FromVariantConverter::size() const
{
    return var_.size();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
inline FromVariantConverter& FromVariantConverter::size(SizeType& n)
{
    n = var_.size();
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
FromVariantConverter& FromVariantConverter::operator()(T& value)
{
    var_.to(value);
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
FromVariantConverter& FromVariantConverter::operator[](T& value)
{
    try
    {
        var_.at(index_).to(value);
        ++index_;
    }
    catch (const error::Conversion& e)
    {
        std::ostringstream oss;
        oss << e.what() << ", for array index " << index_;
        throw error::Conversion(oss.str());
    }
    catch (const error::Access&)
    {
        std::ostringstream oss;
        oss << "wamp::error::Conversion: Attemping to access field type "
            << typeNameOf(var_) << " as array";
        throw error::Conversion(oss.str());
    }
    catch (const std::out_of_range&)
    {
        std::ostringstream oss;
        oss << "wamp::error::Conversion: Cannot extract more than " << index_
            << " elements from the array";
        throw error::Conversion(oss.str());
    }
 
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
FromVariantConverter& FromVariantConverter::operator()(const String& key,
                                                       T& value)
{
    try
    {
        var_.at(key).to(value);
    }
    catch (const error::Conversion& e)
    {
        std::ostringstream oss;
        oss << e.what() << ", for object member \"" << key << '"';
        throw error::Conversion(oss.str());
    }
    catch (const error::Access&)
    {
        std::ostringstream oss;
        oss << "wamp::error::Conversion: Attemping to access field type "
            << typeNameOf(var_) << " as object using key \"" << key << '"';
        throw error::Conversion(oss.str());
    }
    catch (const std::out_of_range&)
    {
        std::ostringstream oss;
        oss << "wamp::error::Conversion: Key \"" << key
            << "\" not found in object";
        throw error::Conversion(oss.str());
    }
 
    return *this;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename U>
FromVariantConverter& FromVariantConverter::operator()(const String& key,
                                                       T& value, U&& fallback)
{
    try
    {
        auto& obj = var_.as<Object>();
        auto kv = obj.find(key);
        if (kv != obj.end())
            kv->second.to(value);
        else
            value = std::forward<U>(fallback);
    }
    catch (const error::Conversion& e)
    {
        std::ostringstream oss;
        oss << e.what() << ", for object member \""  << key << '"';
        throw error::Conversion(oss.str());
    }
    catch (const error::Access&)
    {
        std::ostringstream oss;
        oss << "wamp::error::Conversion: Attemping to access field type "
            << typeNameOf(var_) << " as object using key \"" << key << '"';
        throw error::Conversion(oss.str());
    }
 
    return *this;
}
 
//------------------------------------------------------------------------------
inline const Variant& FromVariantConverter::variant() const {return var_;}
 
} // namespace wamp
 
#ifndef CPPWAMP_COMPILED_LIB
    #include "internal/variant.ipp"
#endif
 
#endif // CPPWAMP_VARIANT_HPP