Any.h

/*
 * Copyright (C) 2004-2011 by Marc Boris Duerner
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef Pt_Any_h
#define Pt_Any_h
 
#include <Pt/TypeTraits.h>
#include <typeinfo>
#include <cstring>
#include <new>
 
namespace Pt {

class Any
{
    template <typename T>
    friend T any_cast(const Any&);
 
    template <typename T>
    friend struct AnyCast;
 
    public:
        class Value
        {
            public:
                virtual ~Value() {}
                virtual Value* clone(char*) const = 0;
                virtual const std::type_info& type() const = 0;
                virtual bool isRef() const = 0;
                virtual void* get() = 0;
                virtual const void* get() const = 0;
        };

        template <typename T>
        class BasicValue : public Value
        {
            public:
                BasicValue(const T& value = T())
                : _value(value)
                { }
 
                const T& value() const
                { return _value;}
 
                T& value()
                { return _value;}
 
                virtual const std::type_info& type() const
                { return typeid(T); }
 
                virtual Value* clone(char* data) const
                {
                    return Any::cloneValue(_value, data);
                }
 
                virtual bool isRef() const
                { return false; }
 
                virtual void* get()
                { return &_value; }
 
                virtual const void* get() const
                { return &_value; }
 
            private:
                T _value;
        };

        template <typename T>
        class BasicRefValue : public Value
        {
            public:
                BasicRefValue(T* value)
                : _value(value)
                { }
 
                virtual const std::type_info& type() const
                { return typeid(T); }
 
                virtual Value* clone(char* data) const
                { return new(data) BasicRefValue(_value); }
 
                virtual bool isRef() const
                { return true; }
 
                virtual void* get()
                { return (void*) _value; }
 
                virtual const void* get() const
                { return _value; }
 
            private:
                T* _value;
        };

        class RefValue : public Value
        {
            public:
                RefValue(void* value, const std::type_info& ti)
                : _value(value)
                , _ti(&ti)
                { }
 
                virtual bool isRef() const
                { return true; }
 
                virtual const std::type_info& type() const
                { return *_ti; }
 
                virtual Any::Value* clone(char* data) const
                { return new(data) RefValue(_value, *_ti); }
 
                virtual void* get()
                { return _value; }
 
                virtual const void* get() const
                { return _value; }
 
            private:
                void* _value;
                const std::type_info* _ti;
        };

        bool dataUsed() const
        { return static_cast<const void*>(_value) == static_cast<const void*>(_data); }
 
    public:
        template <typename T>
        Any(const T& type)
        : _value(0)
        {
            _value = this->createValue(type);
        }

        template <typename T>
        explicit Any(T* type)
        : _value(0)
        {
            // storage is always large enough for BasicRefValue
            _value = new(static_cast<void*>(_data)) BasicRefValue<T>(type);
        }

        Any(void* type, const std::type_info& ti)
        : _value(0)
        {
            // storage is always large enough for RefValue
            _value = new(static_cast<void*>(_data)) RefValue(type, ti);
        }

        Any()
        : _value(0)
        { }

        Any& assign(Value* value);

        Any(const Any& val);

        ~Any()
        {
            if (_value)
            {
                if (dataUsed())
                    _value->~Value();
                else
                    delete _value;
            }
        }

        void clear()
        {
            if (_value)
            {
                if (dataUsed())
                    _value->~Value();
                else
                    delete _value;
                _value = 0;
            }
        }

        inline bool empty() const
        { return !_value; }

        Any& swap(Any& other);

        inline bool isRef() const
        { return _value && _value->isRef(); }

        const std::type_info& type() const
        { return _value ? _value->type() : typeid(void); }

        template <typename T>
        Any& operator=(const T& rhs)
        {
            clear();
            _value = this->createValue(rhs);
            return *this;
        }

        template <typename T>
        Any& operator=(T* rhs)
        {
            clear();
            _value = new(static_cast<void*>(_data)) BasicRefValue<T>(rhs);
            return *this;
        }

        Any& operator=(const Any& rhs);

        const Any::Value* value() const
        { return _value; }

        Any::Value* value()
        { return _value; }

        void* get()
        {
            if(_value)
                return _value->get();
 
            return 0;
        }

        const void* get() const
        {
            if(_value)
                return _value->get();
 
            return 0;
        }
 
    private:
        static const unsigned sizeofData = sizeof(RefValue);
 
        template <typename T>
        struct IsSmallObject : BoolConstant< sizeof(BasicValue<T>) <= Any::sizeofData >
        {
        };
 
        template <typename T>
        static Value* cloneValue(const T& value, char* data);
 
        template <typename T>
        static Value* cloneValue(const T& value, char* data, TrueType);
 
        template <typename T>
        static Value* cloneValue(const T& value, char* data, FalseType);
 
        template <typename T>
        Value* createValue(const T& value);
 
        template <typename T>
        Value* createValue(const T& value, TrueType);
 
        template <typename T>
        Value* createValue(const T& value, FalseType);
 
    private:
        Value* _value;

        alignas(Value) char _data[sizeofData];
};
 
template <typename T>
inline Any::Value* Any::cloneValue(const T& value, char* data)
{
    return Any::cloneValue(value, data, IsSmallObject<T>());
}
 
template <typename T>
inline Any::Value* Any::cloneValue(const T& value, char* data, TrueType)
{
    return new(data) BasicValue<T>(value);
}
 
template <typename T>
inline Any::Value* Any::cloneValue(const T& value, char*, FalseType)
{
    return new BasicValue<T>(value);
}
 
template <typename T>
inline Any::Value* Any::createValue(const T& value)
{
    return this->createValue(value, IsSmallObject<T>());
}
 
template <typename T>
inline Any::Value* Any::createValue(const T& value, TrueType)
{
    return new(static_cast<void*>(_data)) BasicValue<T>(value);
}
 
template <typename T>
inline Any::Value* Any::createValue(const T& value, FalseType)
{
    return new BasicValue<T>(value);
}

template <typename T>
struct AnyCast
{
    static T cast(const Any& any)
    {
        // NOTE:
        // - the first if(...) may not work properly on Linux when loading libs,
        //   so there is also a comparison of string names (second if(...))
        // - but: the name() method necessary for string comparison does not
        //   exist on WinCE, so the second if(...) is not compiled for WinCE
        typedef typename TypeTraits<T>::Value ValueT;
 
        if( any.type() == typeid(ValueT) )
        {
            void* v = any._value->get();
            ValueT* vtp = reinterpret_cast<ValueT*>(v);
            return *vtp;
        }
 
#ifndef _WIN32_WCE
        else if( 0 == std::strcmp(any.type().name(), typeid(ValueT).name() ) )
        {
            void* v = any._value->get();
            ValueT* vtp = reinterpret_cast<ValueT*>(v);
            return *vtp;
        }
#endif
 
        throw std::bad_cast();
    }
};

template <typename T>
struct AnyCast<T*>
{
    static T* cast(const Any& any)
    {
        // NOTE:
        // - the first if(...) may not work properly on Linux when loading libs,
        //   so there is also a comparison of string names (second if(...))
        // - but: the name() method necessary for string comparison does not
        //   exist on WinCE, so the second if(...) is not compiled for WinCE
        typedef typename TypeTraits<T>::Value ValueT;
 
        if( any.type() == typeid(ValueT) )
        {
            void* v = any._value->get();
            ValueT* vtp = reinterpret_cast<ValueT*>(v);
            return vtp;
        }
 
#ifndef _WIN32_WCE
        else if( 0 == std::strcmp(any.type().name(), typeid(ValueT).name() ) )
        {
            void* v = any._value->get();
            ValueT* vtp = reinterpret_cast<ValueT*>(v);
            return vtp;
        }
#endif
 
        throw std::bad_cast();
    }
};

template <typename T>
inline T any_cast(const Any& any)
{
    return AnyCast<T>::cast(any);
}
 
 
inline Any& Any::assign(Value* value)
{
    clear();
    _value = value->clone(_data);
    return *this;
}
 
 
inline Any::Any(const Any& val)
: _value(0)
{
    if (val._value)
        _value = val._value->clone(_data);
}
 
 
inline Any& Any::swap(Any& rhs)
{
    if (dataUsed())
    {
        if (rhs.dataUsed())
        {
            Any tmp(*this);
            *this = rhs;
            rhs = tmp;
        }
        else
        {
            Value* tmp = _value;
            _value = rhs._value;
            rhs._value = tmp->clone(rhs._data);
            tmp->~Value();
        }
    }
    else
    {
        if (rhs.dataUsed())
        {
            Value* tmp = rhs._value;
            rhs._value = _value;
            _value = tmp->clone(_data);
            tmp->~Value();
        }
        else
        {
            Value* tmp = rhs._value;
            rhs._value = _value;
            _value = tmp;
        }
    }
 
    return *this;
}
 
 
inline Any& Any::operator=(const Any& rhs)
{
    clear();
 
    if (rhs._value)
        _value = rhs._value->clone(_data);
 
    return *this;
}
 
} // namespace
 
#endif