wxany.h

Go to the documentation of this file.

#ifndef wxany_h
#define wxany_h
 
// WarpX includes
#include "wxexcept.h"
 
// std includes
#include <algorithm>
#include <cstddef>
#include <stdint.h>
#include <string>
#include <typeinfo>
#include <vector>
 
class WxAny;
 
namespace wxm
{
namespace detail
{
template<class T> struct wxany_arithmetic_caster
{
    T as_value(const WxAny& v) const;
};
 
struct wxany_string_caster
{
    std::string as_value(const WxAny& v) const;
};
 
template<class T> struct wxany_avector_caster
{
    std::vector<T> as_value(const WxAny& v) const;
};
 
struct wxany_svector_caster
{
    std::vector<std::string> as_value(const WxAny& v) const;
};
 
template<class T> struct wxany_caster
{
    T as_value(const WxAny& v) const;
};
 
template<> struct wxany_caster<std::string> : public wxany_string_caster
{
};
 
template<> struct wxany_caster<std::vector<std::string>> : public wxany_svector_caster
{
};
 
#define WXCASTER_HELPER(TYPE)                                                            \
    template<> struct wxany_caster<TYPE> : public wxany_arithmetic_caster<TYPE>          \
    {                                                                                    \
    }
 
WXCASTER_HELPER(bool);
WXCASTER_HELPER(char);
WXCASTER_HELPER(unsigned char);
WXCASTER_HELPER(short);
WXCASTER_HELPER(unsigned short);
WXCASTER_HELPER(int);
WXCASTER_HELPER(unsigned int);
WXCASTER_HELPER(long);
WXCASTER_HELPER(unsigned long);
WXCASTER_HELPER(long long);
WXCASTER_HELPER(unsigned long long);
WXCASTER_HELPER(float);
WXCASTER_HELPER(double);
 
#undef WXCASTER_HELPER
 
#define WXVECCASTER_HELPER(TYPE)                                                         \
    template<>                                                                           \
    struct wxany_caster<std::vector<TYPE>> : public wxany_avector_caster<TYPE>           \
    {                                                                                    \
    }
 
WXVECCASTER_HELPER(bool);
WXVECCASTER_HELPER(char);
WXVECCASTER_HELPER(unsigned char);
WXVECCASTER_HELPER(short);
WXVECCASTER_HELPER(unsigned short);
WXVECCASTER_HELPER(int);
WXVECCASTER_HELPER(unsigned int);
WXVECCASTER_HELPER(long);
WXVECCASTER_HELPER(unsigned long);
WXVECCASTER_HELPER(long long);
WXVECCASTER_HELPER(unsigned long long);
WXVECCASTER_HELPER(float);
WXVECCASTER_HELPER(double);
 
#undef WXVECCASTER_HELPER
} // namespace detail
} // namespace wxm
 
class WxAny
{
    template<class T>
    T as_value_impl(wxm::detail::wxany_caster<T> t = wxm::detail::wxany_caster<T>()) const
    {
        return t.as_value(*this);
    }
 
public:
    WxAny() : content(nullptr)
    {
    }
 
    template<typename VALUETYPE>
    WxAny(const VALUETYPE& value) : content(new _WxHolder<VALUETYPE>(value))
    {
    }
 
    WxAny(const WxAny& other) : content(other.content ? other.content->clone() : nullptr)
    {
    }
 
    WxAny(WxAny&& other) noexcept : content(other.content)
    {
        other.content = nullptr;
    }
 
    ~WxAny()
    {
        delete content;
    }
 
    WxAny& swap(WxAny& rhs)
    {
        std::swap(content, rhs.content);
        return *this;
    }
 
    WxAny& operator=(const WxAny& rhs)
    {
        WxAny(rhs).swap(*this);
        return *this;
    }
 
    WxAny& operator=(WxAny&& rhs) noexcept
    {
        if (&rhs != this)
        {
            swap(rhs);
        }
        return *this;
    }
 
    template<typename VALUETYPE> WxAny& operator=(const VALUETYPE& rhs)
    {
        WxAny(rhs).swap(*this);
        return *this;
    }
 
    bool empty() const
    {
        return !content;
    }
 
    const std::type_info& type() const
    {
        return content ? content->type() : typeid(void);
    }
 
    int payloadSizeInBytes() const
    {
        return content ? content->sizeInBytes() : -1;
    }
 
    template<typename VALUETYPE> const VALUETYPE* to_ptr() const
    {
        // return pointer to held object or NULL if wrong type
        return type() == typeid(VALUETYPE)
                   ? &static_cast<_WxHolder<VALUETYPE>*>(content)->held
                   : 0;
    }
 
    const void* to_void_ptr() const
    {
        return content->void_ptr();
    }
 
    void* to_void_ptr()
    {
        return content->void_ptr();
    }
 
    template<typename VALUETYPE> VALUETYPE to_value() const
    {
        return as_value_impl(wxm::detail::wxany_caster<VALUETYPE>());
    }
 
private:
    class _WxPlaceHolder
    {
    public:
        // dtor
        virtual ~_WxPlaceHolder() = default;
 
        // typeinfo: must be provided by children
        virtual const std::type_info& type() const = 0;
 
        // sizeInBytes: must be provided by children
        virtual int sizeInBytes() const = 0;
 
        // make a copy: must be provided by children
        virtual _WxPlaceHolder* clone() const = 0;
 
        // return object as a const void *
        virtual const void* void_ptr() const = 0;
 
        // return object as a void *
        virtual void* void_ptr() = 0;
    };
 
    template<typename VALUETYPE> class _WxHolder : public _WxPlaceHolder
    {
    public:
        _WxHolder(const VALUETYPE& value) : held(value)
        {
        }
 
        // type_info about VALUETYPE
        virtual const std::type_info& type() const
        {
            return typeid(VALUETYPE);
        }
 
        // size in bytes of stored value
        virtual int sizeInBytes() const
        {
            return sizeof(VALUETYPE);
        }
 
        // make a copy of held object
        virtual _WxPlaceHolder* clone() const
        {
            return new _WxHolder(held);
        }
 
        // return object as a const void *
        virtual const void* void_ptr() const
        {
            return reinterpret_cast<const void*>(&held);
        }
 
        // return object as a void *
        virtual void* void_ptr()
        {
            return reinterpret_cast<void*>(&held);
        }
 
        VALUETYPE held; // held object
    };
 
    _WxPlaceHolder* content;
};
 
template<typename VALUETYPE>
VALUETYPE wx_access_payload_with_type_check(const WxAny& operand)
{
    // return object or throw exception if types do not match
    const VALUETYPE* result = operand.template to_ptr<VALUETYPE>();
 
    // if it is not null, return value else thow exception
    if (result)
        return *result;
    else
    {
        WxExcept wxe("wx_access_payload_with_type_check : ");
        wxe << "Attempted to assign '" << operand.type().name() << "' as '"
            << typeid(VALUETYPE).name() << "'" << std::endl;
        throw wxe;
    }
    //  throw std::bad_cast();
}
 
template<typename VALUETYPE> VALUETYPE wx_access_payload_with_type_check(WxAny& operand)
{
    // return object or throw exception if types do not match
    const VALUETYPE* result = operand.template to_ptr<VALUETYPE>();
 
    // if it is not null, return value else thow exception
    if (result)
        return *result;
    else
        throw std::bad_cast();
}
 
#include "detail/wxany.tcc"
 
#endif // wxany_h