any.hpp

#ifndef SIPLASPLAS_TYPEERASURE_ANY_HPP
#define SIPLASPLAS_TYPEERASURE_ANY_HPP

#include "simpleany.hpp"
#include "function.hpp"
#include "field.hpp"
#include <siplasplas/utility/hash.hpp>

namespace cpp
{

template<
    typename Storage,
    typename FunctionsStorage = Storage,
    typename FunctionArgsStorage = FunctionsStorage,
    typename AttributesStorage = FunctionsStorage
>
class Any : public SimpleAny<Storage>
{
public:
    using Base = SimpleAny<Storage>;
    using SimpleAny<Storage>::SimpleAny;

    using Method = cpp::typeerasure::Function<FunctionsStorage, FunctionArgsStorage>;
    using Attribute = cpp::typeerasure::Field<AttributesStorage>;

    template<typename Class, typename... Args>
    static Any create(Args&&... args)
    {
        return SimpleAny<Storage>::template create<Class>(std::forward<Args>(args)...);
    }

    class MethodProxy
    {
    public:
        MethodProxy(Method& method, Any* this_) :
            _method{&method},
            _this{this_}
        {}

        template<typename... Args>
        auto operator()(Args&&... args)
        {
            return (*_method)(_this->getReference(), std::forward<Args>(args)...);
        }

        template<typename... Args>
        auto operator()(Args&&... args) const
        {
            return (*_method)(_this->getReference(), std::forward<Args>(args)...);
        }

        template<typename Callable>
        MethodProxy& operator=(Callable&& callable)
        {
            *_method = std::forward<Callable>(callable);
            return *this;
        }

        const Method& method() const
        {
            return *_method;
        }

        Method& method()
        {
            return *_method;
        }

    private:
        Method* _method;
        Any* _this;
    };

    class ConstMethodProxy
    {
    public:
        ConstMethodProxy(const Method& method, const Any* this_) :
            _method{&method},
            _this{this_}
        {}

        template<typename... Args>
        auto operator()(Args&&... args) const
        {
            return (*_method)(_this->getReference(), std::forward<Args>(args)...);
        }

        const Method& method() const
        {
            return *_method;
        }

    private:
        const Method* _method;
        const Any* _this;
    };

    class AttributeProxy
    {
    public:
        AttributeProxy(Attribute& attribute, Any* this_) :
            _attribute{&attribute},
            _this{this_}
        {}

        template<typename Invokable>
        std::enable_if_t<
            cpp::function_kind<std::decay_t<Invokable>>() == cpp::FunctionKind::MEMBER_OBJECT,
            AttributeProxy&
        >
        operator=(Invokable&& invokable)
        {
            (*_attribute) = std::forward<Invokable>(invokable);
            return *this;
        }

        template<typename T>
        std::enable_if_t<
            cpp::function_kind<std::decay_t<T>>() != cpp::FunctionKind::MEMBER_OBJECT,
            AttributeProxy&
        >
        operator=(T&& value)
        {
            get<std::decay_t<T>>() = std::forward<T>(value);
            return *this;
        }

        template<typename T>
        T& get()
        {
            return _attribute->template getAs<T>(_this->simpleAny());
        }

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

        template<typename T>
        const T& get() const
        {
            return _attribute->template getAs<T>(_this->simpleAny());
        }

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

        const Attribute& attribute() const
        {
            return *_attribute;
        }

        Attribute& attribute()
        {
            return *_attribute;
        }

    private:
        Attribute* _attribute;
        Any* _this;
    };

    class ConstAttributeProxy
    {
    public:
        ConstAttributeProxy(const Attribute& attribute, const Any* this_) :
            _attribute{&attribute},
            _this{this_}
        {}

        template<typename T>
        const T& get() const
        {
            return _attribute->template getAs<T>(_this->simpleAny());
        }

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

        const Attribute& attribute() const
        {
            return *_attribute;
        }

    private:
        const Attribute* _attribute;
        const Any* _this;
    };


    MethodProxy operator()(const std::string& name)
    {
        return {_methods[name], this};
    }

    ConstMethodProxy operator()(const std::string& name) const
    {
        SIPLASPLAS_ASSERT(hasMethod(name))("Class {} has no method named '{}'", Base::typeInfo().typeName(), name);
        return {_methods[name], this};
    }

    AttributeProxy operator[](const std::string& name)
    {
        return {_attributes[name], this};
    }

    ConstAttributeProxy operator[](const std::string& name) const
    {
        SIPLASPLAS_ASSERT(hasAttribute(name))("Class {} has no attribute named '{}'", Base::typeInfo().typeName(), name);
        return {_attributes[name], this};
    }

    bool hasMethod(const std::string& name) const
    {
        auto it = _methods.find(name);

        if(it != _methods.end())
        {
            return !it->second.empty();
        }
        else
        {
            return false;
        }
    }

    bool hasAttribute(const std::string& name) const
    {
        auto it = _attributes.find(name);

        if(it != _attributes.end())
        {
            return !it->second.empty();
        }
        else
        {
            return false;
        }
    }

    ::cpp::SimpleAny<Storage>& simpleAny()
    {
        return *static_cast<::cpp::SimpleAny<Storage>*>(this);
    }

    const ::cpp::SimpleAny<Storage>& simpleAny() const
    {
        return *static_cast<::cpp::SimpleAny<Storage>*>(this);
    }

private:
    cpp::HashTable<std::string, Method> _methods;
    cpp::HashTable<std::string, Attribute> _attributes;
};

using Any8  = Any<DeadPoolStorage<8>>;

using Any16 = Any<DeadPoolStorage<16>>;

using Any32 = Any<DeadPoolStorage<32>>;

using Any64 = Any<DeadPoolStorage<64>>;

using ConstReferenceAny = Any<ConstNonOwningStorage, DeadPoolStorage<32>>;

using ReferenceAny = Any<NonOwningStorage, DeadPoolStorage<32>>;

}

#endif // SIPLASPLAS_TYPEERASURE_ANY_HPP