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/function_traits.hpp>
#include <siplasplas/utility/typeinfo.hpp>
#include <siplasplas/constexpr/arrayview.hpp>
#include <siplasplas/constexpr/meta.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,
    END_OF_ENUM
};

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

template<typename T>
ValueSemanticsOperationFunction valueSemanticsOperation(ValueSemanticsOperation operation)
{
    static ValueSemanticsOperationFunction operations[static_cast<std::size_t>(ValueSemanticsOperation::END_OF_ENUM)] = {
        [](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 cpp::TypeInfo::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);
        }
    }

    constexpr cpp::constexp::ConstArrayView<TypeInfo> arguments() const
    {
        return _functionArgs;
    }

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

    template<typename T>
    static constexpr TypeInfo get(const T&)
    {
        return TypeInfo::get<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:
    struct TypeToTypeInfo
    {
        using value_type = TypeInfo;

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

    template<typename T>
    constexpr TypeInfo(meta::identity<T>) :
        cpp::TypeInfo{cpp::TypeInfo::get<T>()},
        _semantics{detail::valueSemanticsOperation<std::decay_t<T>>},
        _functionArgs{
            cpp::constexp::SequenceToArray<
                cpp::function_arguments<T>,
                TypeToTypeInfo
            >::get()
        }
    {}

    detail::ValueSemantics _semantics;
    cpp::constexp::ConstArrayView<TypeInfo> _functionArgs;

};

}

}

#endif // SIPLASPLAS_TYPEERASURE_TYPEINFO_HPP