Traverser.h

#pragma once
 
#include "spark/patterns/Composite.h"
#include "spark/patterns/details/Traverser.h"
 
#include <functional>
 
namespace spark::patterns
{
    template <typename NodeType, typename... FnArgsTypes>
    class Traverser
    {
    public:
        using FnType = std::function<void(NodeType*, FnArgsTypes&&...)>;
 
        explicit Traverser(FnType apply, FnType pre = {}, FnType post = {})
            : m_pre(std::move(pre)), m_apply(std::move(apply)), m_post(std::move(post)) {}
 
        void apply(NodeType* child, FnArgsTypes&&... args)
        {
            if (!m_apply)
                return;
            std::invoke(m_apply, child, std::forward<FnArgsTypes>(args)...);
        }
 
        void pre(NodeType* child, FnArgsTypes&&... args)
        {
            if (!m_pre)
                return;
            std::invoke(m_pre, child, std::forward<FnArgsTypes>(args)...);
        }
 
        void post(NodeType* child, FnArgsTypes&&... args)
        {
            if (!m_post)
                return;
            std::invoke(m_post, child, std::forward<FnArgsTypes>(args)...);
        }
 
    private:
        FnType m_pre, m_apply, m_post;
    };
 
    template <typename NodeType, typename... FnArgsTypes>
    Traverser<NodeType, FnArgsTypes...> make_traverser(typename Traverser<NodeType, FnArgsTypes...>::FnType apply,
                                                       typename Traverser<NodeType, FnArgsTypes...>::FnType pre = {},
                                                       typename Traverser<NodeType, FnArgsTypes...>::FnType post = {})
    {
        return Traverser<NodeType, FnArgsTypes...>(std::move(apply), std::move(pre), std::move(post));
    }
 
    template <typename NodeType, typename... FnArgsTypes>
    void traverse_tree(NodeType* parent, Traverser<NodeType, FnArgsTypes...>& traverser, FnArgsTypes&&... context)
    {
        details::TreeTraverserCaller<NodeType, FnArgsTypes...>::exec(parent, traverser, std::forward<FnArgsTypes>(context)...);
    }
}