field.hpp

#ifndef SIPLASPLAS_TYPEERASURE_FIELD_HPP
#define SIPLASPLAS_TYPEERASURE_FIELD_HPP

#include "function.hpp"

namespace cpp
{

namespace typeerasure
{

template<typename Storage, typename ObjectArgStorage = Storage>
class Field
{
public:
    Field() = default;

    bool empty() const
    {
        return _invoke.empty();
    }

    cpp::FunctionKind kind() const
    {
        return _invoke.kind();
    }

    template<typename T, typename = std::enable_if_t<
        std::is_member_object_pointer<std::decay_t<T>>::value
    >>
    Field(T&& field) :
        _invoke{std::forward<T>(field)}
    {}

    template<typename Object>
    decltype(auto) get(const Object& object) const
    {
        return _invoke(object);
    }

    template<typename T, typename Object>
    decltype(auto) getAs(const Object& object) const
    {
        return get(object).template get<T>();
    }

    template<typename Object>
    decltype(auto) get(Object& object) const
    {
        return _invoke(object);
    }

    template<typename T, typename Object>
    decltype(auto) getAs(Object& object) const
    {
        return get(object).template get<T>();
    }

    template<typename Storage_>
    decltype(auto) get(const cpp::SimpleAny<Storage_>& object) const
    {
        return _invoke(object.getReference());
    }

    template<typename T, typename Storage_>
    decltype(auto) getAs(const cpp::SimpleAny<Storage_>& object) const
    {
        return get(object).template get<T>();
    }

    template<typename Storage_>
    decltype(auto) get(cpp::SimpleAny<Storage_>& object) const
    {
        return _invoke(object.getReference());
    }

    decltype(auto) get(cpp::ReferenceSimpleAny& object) const
    {
        return _invoke(object);
    }

    decltype(auto) get(cpp::ConstReferenceSimpleAny& object) const
    {
        return _invoke(object);
    }
    template<typename T, typename Storage_>
    decltype(auto) getAs(cpp::SimpleAny<Storage_>& object) const
    {
        return get(object).template get<T>();
    }

    template<typename T>
    std::enable_if_t<
        std::is_member_object_pointer<std::decay_t<T>>::value,
        Field&
    >
    operator=(T&& field)
    {
        _invoke = std::forward<T>(field);
        return *this;
    }

    template<typename T>
    const T& get() const
    {
        return _invoke.template get<T>();
    }

    template<typename T>
    T& get()
    {
        return _invoke.template get<T>();
    }

private:
    cpp::typeerasure::Function<Storage, ObjectArgStorage, cpp::NonOwningStorage> _invoke;
};


using Field8  = Field<DeadPoolStorage<8>>;

using Field16 = Field<DeadPoolStorage<16>>;

using Field32 = Field<DeadPoolStorage<32>>;

using Field64 = Field<DeadPoolStorage<64>>;

}

}

#endif // SIPLASPLAS_TYPEERASURE_FIELD_HPP