typeinfo.hpp

#ifndef SIPLASPLAS_TYPEERASURE_TYPEINFO_HPP
#define SIPLASPLAS_TYPEERASURE_TYPEINFO_HPP

#include "features/valuesemantics.hpp"
#include <siplasplas/utility/memory_manip.hpp>
#include <siplasplas/utility/meta.hpp>
#include <siplasplas/utility/function_traits.hpp>

namespace cpp
{

namespace typeerasure
{

namespace detail
{

enum class ValueSemanticsOperation : std::size_t
{
    COPY_CONSTRUCT = 0,
    MOVE_CONSTRUCT = 1,
    COPY_ASSIGN    = 2,
    MOVE_ASSIGN    = 3,
    DESTROY        = 4
};

using ValueSemanticsOperationFunction = void(*)(void*, const void*);

template<typename T>
ValueSemanticsOperationFunction valueSemanticsOperation(ValueSemanticsOperation operation)
{
    static ValueSemanticsOperationFunction operations[] = {
        +[](void* object, const void* other) {
            features::CopyConstructible::apply<T>(object, other);
        },
        +[](void* object, const void* other) {
            features::MoveConstructible::apply<T>(object, const_cast<void*>(other));
        },
        +[](void* object, const void* other) {
            features::CopyAssignable::apply<T>(object, other);
        },
        +[](void* object, const void* other) {
            features::MoveAssignable::apply<T>(object, const_cast<void*>(other));
        },
        +[](void* object, const void*) {
            features::Destructible::apply<T>(object);
        }
    };

    return operations[static_cast<std::size_t>(operation)];
}

using ValueSemantics = decltype(&valueSemanticsOperation<int>);

}

class TypeInfo
{
public:
    detail::ValueSemantics semantics() const
    {
#if UINTPTR_MAX == UINT64_MAX // See constructor bellow
        return cpp::detail::untagPointer(_semantics);
#else
        return _semantics;
#endif
    }

    std::size_t sizeOf() const
    {
        return _sizeOf;
    }

    const char* typeName() const
    {
        return _typeId.name().c_str();
    }

    bool isPointer() const
    {
        return _isPointer;
    }

    detail::ValueSemanticsOperationFunction semantics(detail::ValueSemanticsOperation operation) const
    {
        return semantics()(operation);
    }

    void copyConstruct(void* where, const void* other) const
    {
        semantics(detail::ValueSemanticsOperation::COPY_CONSTRUCT)(where, other);
    }

    void moveConstruct(void* where, void* other) const
    {
        semantics(detail::ValueSemanticsOperation::MOVE_CONSTRUCT)(where, const_cast<const void*>(other));
    }

    void copyAssign(void* where, const void* other) const
    {
        semantics(detail::ValueSemanticsOperation::COPY_ASSIGN)(where, other);
    }

    void moveAssign(void* where, void* other) const
    {
        semantics(detail::ValueSemanticsOperation::MOVE_ASSIGN)(where, const_cast<const void*>(other));
    }

    void destroy(void* where) const
    {
        if(!isPointer())
        {
            semantics(detail::ValueSemanticsOperation::DESTROY)(where, nullptr);
        }
    }

    template<typename T>
    static constexpr TypeInfo get()
    {
        return TypeInfo{meta::identity<T>()};
    }

    friend constexpr bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
    {
        return lhs._semantics == rhs._semantics;
    }

    friend constexpr bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
    {
        return !(lhs == rhs);
    }

private:
    template<typename T>
    constexpr TypeInfo(meta::identity<T>) :
// If virtual addresses have 64 bits, use a use a tagged pointer to store the alignment,
// else use an extra member
#if UINTPTR_MAX == UINT64_MAX
        _semantics{cpp::detail::tagPointer(&detail::valueSemanticsOperation<T>, alignof(T))},
        _sizeOf{sizeof(T)},
        _typeId{ctti::type_id<T>()},
        _isPointer{
            std::is_pointer<T>::value &&
            cpp::function_kind<T>() != cpp::FunctionKind::FREE_FUNCTION
        }
    {
        static_assert(alignof(T) < (1 << 16), "Alignment of T cannot be tagged in a pointer, its value overflows a 16 bit unsigned integer");
    }

public:
    std::size_t alignment() const
    {
        return cpp::detail::readTaggedPointer(_semantics);
    }

private:
#else
        _semantics{&valueSemanticsOperation<T>},
        _alignment{alignof(T)},
        _sizeOf{sizeof(T)},
        _typeId{ctti::type_id<T>()},
        _isPointer{
            std::is_pointer<T>::value &&
            cpp::function_kind<T>() != cpp::FunctionKind::FREE_FUNCTION
        }
    {}

public:
    constexpr std::size_t alignment() const
    {
        return _alignment;
    }

private:
    std::size_t _alignment;
#endif // if not 64 bit
    detail::ValueSemantics _semantics;
    std::size_t _sizeOf;
    ctti::type_id_t _typeId;
    bool _isPointer;
};

}

}

#endif // SIPLASPLAS_TYPEERASURE_TYPEINFO_HPP