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 sizeof(BasicValue<T>) > Any::sizeofData ? new BasicValue(_value)
                                                                   : new(data) BasicValue(_value); 
                }

                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 = sizeof(BasicValue<T>) > Any::sizeofData ? new BasicValue<T>(type)
                                                             : new(static_cast<void*>(_data)) BasicValue<T>(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 = sizeof(BasicValue<T>) > Any::sizeofData ? new BasicValue<T>(rhs)
                                                             : new(static_cast<void*>(_data)) BasicValue<T>(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);

        Value* _value;

        char _data[sizeofData];
};

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 xxx

#endif