type_info.h

/*****************************************************/
/* lean built-in types          (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_TYPE_INFO
#define LEAN_TYPE_INFO

#include "lean.h"
#include <typeinfo>
#include "meta/strip.h"

namespace lean
{

namespace types
{

struct type_info
{
    const std::type_info &type;
    const size_t size;

    type_info(const std::type_info &type, size_t size)
        : type(type),
        size(size) { }
};

namespace impl
{
    template <class Type>
    struct robust_sizeof { static const size_t value = sizeof(Type); };
    template <>
    struct robust_sizeof<void> { static const size_t value = 0; };
}

template <class Type>
inline const type_info& get_type_info()
{
    static type_info info(
            typeid(Type),
            impl::robust_sizeof<typename lean::strip_modref<Type>::type>::value
        );
    return info;
}


template <class Type>
LEAN_INLINE bool is_type(const std::type_info &type)
{
    return typeid(Type) == type;
}


template <class Value>
LEAN_INLINE Value* to_type(const std::type_info &type, void *value)
{
    return is_type<Value>(type)
        ? static_cast<Value*>(value)
        : nullptr;
}

template <class Value>
LEAN_INLINE const Value* to_type(const std::type_info &type, const void *value)
{
    return to_type<Value>(type, const_cast<void*>(value));
}

template <class Value>
LEAN_INLINE volatile Value* to_type(const std::type_info &type, volatile void *value)
{
    return to_type<Value>(type, const_cast<void*>(value));
}

template <class Value>
LEAN_INLINE const volatile Value* to_type(const std::type_info &type, const volatile void *value)
{
    return to_type<Value>(type, const_cast<void*>(value));
}


LEAN_INLINE void* get_element(size_t stride, void *value, size_t offset)
{
    return reinterpret_cast<char*>(value) + offset * stride;
}

LEAN_INLINE const void* get_element(size_t stride, const void *value, size_t offset)
{
    return get_element(stride, const_cast<void*>(value), offset);
}

LEAN_INLINE volatile void* get_element(size_t stride, volatile void *value, size_t offset)
{
    return get_element(stride, const_cast<void*>(value), offset);
}

LEAN_INLINE const volatile void* get_element(size_t stride, const volatile void *value, size_t offset)
{
    return get_element(stride, const_cast<void*>(value), offset);
}


} // namespace

using types::type_info;
using types::get_type_info;

using types::is_type;
using types::to_type;
using types::get_element;

} // namespace

#endif