any.h

/*****************************************************/
/* lean Containers              (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_CONTAINERS_ANY
#define LEAN_CONTAINERS_ANY

#include "../lean.h"
#include "../meta/strip.h"
#include "../smart/cloneable.h"
#include "../memory/heap_bound.h"
#include <typeinfo>

namespace lean
{
namespace containers
{

class any : public cloneable
{
    template <class Value>
    friend Value* any_cast(any*);

protected:
    LEAN_INLINE any& operator =(const any&) { return *this; }

    virtual void* get_any_ptr(const std::type_info& type) = 0;

public:
    virtual ~any() { }
    
    virtual const std::type_info& type() const = 0;
};

template <class Value, class Heap = default_heap>
class any_value : public heap_bound<Heap>, public any
{
private:
    Value m_value;

protected:
    void* get_any_ptr(const std::type_info& type)
    {
        return (typeid(Value) == type)
            ? &m_value
            : nullptr;
    }

public:
    typedef Value value_type;

    LEAN_INLINE any_value()
        : m_value() { }
    LEAN_INLINE any_value(const value_type &value)
        : m_value(value) { }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE any_value(value_type &&value)
        : m_value(std::move(value)) { }
#endif

    LEAN_INLINE any_value& operator =(const value_type &value)
    {
        m_value = value;
        return *this;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE any_value& operator =(value_type &&value)
    {
        m_value = std::move(value);
        return *this;
    }
#endif

    LEAN_INLINE value_type& get() { return m_value; }
    LEAN_INLINE const value_type& get() const { return m_value; }
    LEAN_INLINE volatile value_type& get() volatile { return m_value; }
    LEAN_INLINE const volatile value_type& get() const volatile { return m_value; }

    LEAN_INLINE const std::type_info& type() const
    {
        return typeid(value_type);
    }

    LEAN_INLINE any_value* clone() const { return new any_value(*this); }
    LEAN_INLINE void destroy() const { delete this; }
};

template <class Value>
LEAN_INLINE Value* any_cast(any *pContainer)
{
    return static_cast<Value*>(
        pContainer
            ? pContainer->get_any_ptr(typeid(Value))
            : nullptr );
}
template <class Value>
LEAN_INLINE const Value* any_cast(const any *pContainer)
{
    return any_cast<const Value>(const_cast<any*>(pContainer));
}
template <class Value>
LEAN_INLINE volatile Value* any_cast(volatile any *pContainer)
{
    return any_cast<volatile Value>(const_cast<any*>(pContainer));
}
template <class Value>
LEAN_INLINE const volatile Value* any_cast(const volatile any *pContainer)
{
    return any_cast<const volatile Value>(const_cast<any*>(pContainer));
}

namespace impl
{
    LEAN_NOINLINE void throw_bad_cast()
    {
        throw std::bad_cast();
    }

} // namespace

template <class Value>
LEAN_INLINE Value any_cast_checked(any *container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    nonref_value_type *pValue = any_cast<nonref_value_type>(container);
    
    if (!pValue)
        impl::throw_bad_cast();

    return *pValue;
}
template <class Value>
LEAN_INLINE Value any_cast_checked(const any *container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast_checked<const nonref_value_type&>(const_cast<any*>(container));
}
template <class Value>
LEAN_INLINE Value any_cast_checked(volatile any *container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast_checked<volatile nonref_value_type&>(const_cast<any*>(container));
}
template <class Value>
LEAN_INLINE Value any_cast_checked(const volatile any *container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast_checked<const volatile nonref_value_type&>(const_cast<any*>(container));
}

template <class Value>
LEAN_INLINE Value any_cast(any &container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast_checked<nonref_value_type&>(&container);
}
template <class Value>
LEAN_INLINE Value any_cast(const any &container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast<const nonref_value_type&>(const_cast<any&>(container));
}
template <class Value>
LEAN_INLINE Value any_cast(volatile any &container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast<volatile nonref_value_type&>(const_cast<any&>(container));
}
template <class Value>
LEAN_INLINE Value any_cast(const volatile any &container)
{
    typedef typename lean::strip_reference<Value>::type nonref_value_type;
    return any_cast<const volatile nonref_value_type&>(const_cast<any&>(container));
}

} // namespace

using containers::any;
using containers::any_value;

using containers::any_cast;
using containers::any_cast_checked;

} // namespace

#ifdef DOXYGEN_READ_THIS


    #define LEAN_NO_ANY_CAST
    #undef LEAN_NO_ANY_CAST
#endif

#ifndef LEAN_NO_ANY_CAST
    using lean::any_cast;
    using lean::any_cast_checked;
#endif

#endif