pipeline.h

#ifndef OE_UTIL_PIPELINE_H
#define OE_UTIL_PIPELINE_H
 
#include <cassert>
#include <memory>
#include <optional>
#include <vector>
#include <map>
 
namespace oe::util
{
    template <typename Request, typename Response, bool TopToBottom>
    class Pipeline;
 
    namespace pipeline
    {
        template <typename Request, typename Response>
        class Handler
        {
            using ConcretePipeline = Pipeline<Request, Response, true>;
 
            public:
                virtual void init() {}
                virtual void clean() {}
 
                virtual ~Handler() {}
 
                virtual Response handle(const Request&& input) = 0;
 
                Response next(const Request&& input)
                {
                    if (_next_handler != nullptr)
                        return _next_handler->handle(std::move(input));
 
                    // No next handler, return default Response
                    return _pipeline->getDefaultResponse();
                }
 
                Response next(const Request& input)
                {
                    if (_next_handler != nullptr)
                        return _next_handler->handle(std::move(input));
 
                    // No next handler, return default Response
                    return _pipeline->getDefaultResponse();
                }
 
            protected:
                ConcretePipeline* _pipeline = nullptr;
 
            private:
                Handler* _next_handler = nullptr;
 
            friend Pipeline<Request, Response, true>;
            friend Pipeline<Request, Response, false>;
        };
 
        template <typename Request, typename Response>
        class LambdaHandler : public Handler<Request, Response>
        {
            using handler_function = Response (*)(const Request&&, Handler<Request, Response>*);
 
            public:
                LambdaHandler(const handler_function& handler) : _handler(handler)
                {}
 
                Response handle(const Request&& input) override
                {
                    return _handler(input, this);
                }
 
            protected:
                handler_function _handler;
        };
    }
 
    template <typename Request, typename Response, bool TopToBottom = true>
    class Pipeline
    {
        public:
            using RequestType = Request;
            using ResponseType = Response;
 
            using PipeHandler = pipeline::Handler<Request, Response>;
 
            template<class... Args>
            Pipeline(Args&&... args) : _default_response(std::forward<Args>(args)...)
            {
 
            }
 
            template <typename T, typename ...Args>
            Pipeline& addPipe(const std::string& name, Args&& ...args)
            {
                std::unique_ptr<T> handler = std::make_unique<T>(std::forward<Args>(args)...);
 
                // Reintepret cast because the pipe order is not used in the handler, thus defaulted to true
                handler->_pipeline = reinterpret_cast<Pipeline<Request, Response, true>*>(this);
 
                _pipes.push_back(std::move(handler));
 
                if (name != "")
                    _pipes_by_name[name] = _pipes.back().get();
 
                _rebuildPipeOrder();
 
                return *this;
            }
 
            void init()
            {
                for (auto& it : _pipes)
                    it->init();
            }
 
            void clean()
            {
                // Clean in reverse
                for (auto it = _pipes.rbegin(); it != _pipes.rend(); ++it)
                    (*it)->clean();
            }
 
            Response run(const Request&& request)
            {
                // Cannot use 'run' on an step-by-step pipe
                assert(!_last_step_pipe);
 
                if (_pipes.size() > 0)
                {
                    if constexpr (TopToBottom)
                    {
                        return _pipes.front()->handle(std::move(request));
                    }
                    else
                    {
                        return _pipes.back()->handle(std::move(request));
                    }
                }
 
                // No pipes, return default Response value
                return _default_response;
            }
 
            Response getDefaultResponse() { return _default_response; }
 
            template<class... Types>
            void generateDefaultResponse(Types... args)
            {
                _default_response = {args...};
            }
 
            template <typename T>
            T* getPipeByName(const std::string& name)
            {
                return static_cast<T*>(_pipes_by_name[name]);
            }
 
            void enableStepByStepMode()
            {
                _last_step_pipe.emplace(0);
 
                for (auto it = _pipes.begin(); it != _pipes.end(); ++it)
                {
                    (*it)->_next_handler = nullptr;
                }
            }
 
            void disableStepByStepMode()
            {
                _last_step_pipe.reset();
                _rebuildPipeOrder();
            }
 
            bool isStepByStepMode()
            {
                return (bool)_last_step_pipe;
            }
 
            std::pair<Response, bool> step(const Request&& request)
            {
                // Cannot use 'step' on an linear pipe
                assert(_last_step_pipe);
 
                PipeHandler* pipe = _pipes[*_last_step_pipe].get();
 
                ++(*_last_step_pipe);
 
                bool has_more_pipes = _last_step_pipe < _pipes.size();
 
                if (!has_more_pipes)
                    *_last_step_pipe = 0;
 
                return {pipe->handle(std::move(request)), has_more_pipes};
            }
 
        protected:
            std::vector<std::unique_ptr<PipeHandler>> _pipes;
            Response _default_response;
 
            std::map<std::string, PipeHandler*> _pipes_by_name;
 
            std::optional<int32_t> _last_step_pipe = std::nullopt;
 
            void _rebuildPipeOrder()
            {
                if constexpr (TopToBottom)
                {
                    PipeHandler* last_handler = _pipes.back().get();
                    last_handler->_next_handler = nullptr;
 
                    for (auto it = _pipes.rbegin()+1; it != _pipes.rend(); ++it)
                    {
                        (*it)->_next_handler = last_handler;
                        last_handler = it->get();
                    }
                }
                else
                {
                    PipeHandler* last_handler = _pipes.front().get();
 
                    last_handler->_next_handler = _pipes.size() > 1
                        ? (_pipes.begin() + 1)->get()
                        : nullptr
                    ;
 
                    for (auto it = _pipes.begin()+1; it != _pipes.end(); ++it)
                    {
                        (*it)->_next_handler = last_handler;
                        last_handler = it->get();
                    }
                }
            }
    };
}
 
#endif