Visitor.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/mutable-config.hpp>
#include <mutable/util/crtp.hpp>
#include <mutable/util/fn.hpp>
#include <mutable/util/macro.hpp>
#include <mutable/util/some.hpp>
#include <mutable/util/tag.hpp>
#include <optional>
#include <type_traits>
 
 
namespace m {
 
struct visit_stop_recursion { };
struct visit_skip_subtree { };
 
namespace detail {
 
template<typename ConcreteVisitor, typename Base>
struct Visitor : crtp<ConcreteVisitor, Visitor, Base>
{
    using crtp<ConcreteVisitor, Visitor, Base>::actual;
 
    static constexpr bool is_const = std::is_const_v<Base>;
 
    using base_type = Base;
 
    using visitor_type = ConcreteVisitor;
 
    template<typename T>
    using Const = std::conditional_t<is_const, const T, T>;
 
    virtual ~Visitor() { }
 
    virtual void operator()(base_type &obj) { obj.accept(actual()); }
};
 
template<typename ConcreteVisitor, typename Base, typename Class, typename... Classes>
struct visitor_method_helper : visitor_method_helper<ConcreteVisitor, Base, Classes...>
{
    using super = visitor_method_helper<ConcreteVisitor, Base, Classes...>;
    template<typename T> using Const = typename super::template Const<T>;
    using super::operator();
    virtual void operator()(Const<Class>&) { }
};
template<typename ConcreteVisitor, typename Base, typename Class>
struct visitor_method_helper<ConcreteVisitor, Base, Class> : Visitor<ConcreteVisitor, Base>
{
    using super = Visitor<ConcreteVisitor, Base>;
    template<typename T> using Const = typename super::template Const<T>;
    using super::operator();
    virtual void operator()(Const<Class>&) { }
};
 
template<typename ConcreteVisitor, typename Base, typename... Hierarchy>
struct VisitorImpl : visitor_method_helper<ConcreteVisitor, Base, Hierarchy...>
{
    using super = visitor_method_helper<ConcreteVisitor, Base, Hierarchy...>;
    template<typename T> using Const = typename super::template Const<T>;
    using super::operator();
};
 
template<typename Callable, typename ResultType, typename Visitor, typename Class, typename... Classes>
struct stl_visit_helper : stl_visit_helper<Callable, ResultType, Visitor, Classes...>
{
    using super = stl_visit_helper<Callable, ResultType, Visitor, Classes...>;
 
    stl_visit_helper(Callable &callable, std::optional<some<ResultType>> &result) : super(callable, result) { }
 
    using super::operator();
    void operator()(typename Visitor::template Const<Class> &obj) override {
        if constexpr (std::is_same_v<void, ResultType>) { this->callable(obj); }
        else { super::result = m::some<ResultType>(this->callable(obj)); }
    }
};
template<typename Callable, typename ResultType, typename Visitor, typename Class>
struct stl_visit_helper<Callable, ResultType, Visitor, Class> : Visitor
{
    Callable &callable;
    std::optional<some<ResultType>> &result;
 
    stl_visit_helper(Callable &callable, std::optional<some<ResultType>> &result) : callable(callable), result(result) { }
 
    using Visitor::operator();
    void operator()(typename Visitor::template Const<Class> &obj) override {
        if constexpr (std::is_same_v<void, ResultType>) { this->callable(obj); }
        else { result = m::some<ResultType>(this->callable(obj)); }
    }
};
 
}
 
template<typename Callable, typename Visitor, typename Base, typename... Hierarchy>
auto visit(Callable &&callable, Base &obj, m::tag<Callable>&& = m::tag<Callable>())
{
    using result_type = std::common_type_t< std::invoke_result_t<Callable, typename Visitor::template Const<Hierarchy>&>... >;
 
    std::optional<some<result_type>> result;
 
    /*----- Create a `visit_helper` and then invoke it on the `obj`. -----*/
    detail::stl_visit_helper<Callable, result_type, Visitor, Hierarchy...> V(callable, result);
    try { V(obj); } catch (visit_stop_recursion) { }
    if constexpr (not std::is_same_v<void, result_type>) {
        return std::move(V.result->value);
    } else {
        return; // result is `void`
    }
}
 
}
 
 
#define M_MAKE_STL_VISITABLE(VISITOR, BASE_CLASS, CLASS_LIST) \
    template<typename Callable> \
    auto visit(Callable &&callable, BASE_CLASS &obj, m::tag<VISITOR>&& = m::tag<VISITOR>()) { \
        return m::visit<Callable, VISITOR, BASE_CLASS CLASS_LIST(M_COMMA_PRE)>(std::forward<Callable>(callable), obj); \
    }
 
#define M_DECLARE_VISITOR(VISITOR_NAME, BASE_CLASS, CLASS_LIST) \
    struct VISITOR_NAME : m::detail::VisitorImpl<VISITOR_NAME, BASE_CLASS CLASS_LIST(M_COMMA_PRE)> { \
        using super = m::detail::VisitorImpl<VISITOR_NAME, BASE_CLASS CLASS_LIST(M_COMMA_PRE)>; \
        using super::operator(); \
    }; \
    M_MAKE_STL_VISITABLE(VISITOR_NAME, BASE_CLASS, CLASS_LIST)