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>
#include <siplasplas/utility/typeinfo.hpp>

namespace cpp
{

namespace typeerasure
{

namespace detail
{

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

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

template<typename T>
ValueSemanticsOperationFunction valueSemanticsOperation(ValueSemanticsOperation operation)
{
    static ValueSemanticsOperationFunction operations[] = {
        +[](void* object, const void*) {
            features::DefaultConstructible::apply<T>(object);
        },
        +[](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 cpp::TypeInfo
{
public:
    detail::ValueSemantics semantics() const
    {
        return _semantics;
    }

    bool isPointer() const
    {
        return _isPointer;
    }

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

    void defaultConstruct(void* where) const
    {
        semantics(detail::ValueSemanticsOperation::DEFAULT_CONSTRUCT)(where, nullptr);
    }

    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>) :
        cpp::TypeInfo{cpp::TypeInfo::get<T>()},
        _semantics{detail::valueSemanticsOperation<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");
    }

    detail::ValueSemantics _semantics;
    bool _isPointer;
};

}

}

#endif // SIPLASPLAS_TYPEERASURE_TYPEINFO_HPP