pipeline.h

#ifndef OE_UTIL_PIPELINE_H
#define OE_UTIL_PIPELINE_H
 
#include <memory>
#include <optional>
 
namespace oe::detail
{
    template<typename Interface>
    struct Implementation;
}
 
namespace oe::util
{
    template <typename Request, typename Response>
    class Pipeline;
 
    namespace pipeline
    {
        template <typename Request, typename Response>
        class Handler
        {
            using ConcretePipeline = Pipeline<Request, Response>;
 
            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(input);
 
                    // No next handler, return default Response
                    return _pipeline->getDefaultResponse();
                }
 
            protected:
                ConcretePipeline* _pipeline = nullptr;
 
            private:
                Handler* _next_handler = nullptr;
 
            friend ConcretePipeline;
        };
        class Handler {…};
 
        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;
        };
        class LambdaHandler : public Handler<Request, Response> {…};
    }
    namespace pipeline {…}
 
    template <typename Request, typename Response>
    class Pipeline
    {
        using PipeHandler = pipeline::Handler<Request, Response>;
        using handler_function = Response (*)(const std::string&, pipeline::Handler<Request, Response>*);
 
        public:
            template<class... Args>
            Pipeline(Args&&... args) : _default_response(std::forward<Args>(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)...);
 
                handler->_pipeline = this;
 
                _pipes.push_back(std::move(handler));
 
                if (name != "")
                    _pipes_by_name[name] = _pipes.back().get();
 
                _rebuildPipeOrder();
 
                return *this;
            }
            Pipeline& addPipe(const std::string& name, Args&& ...args) {…}
 
            void init()
            {
                for (auto& it : _pipes)
                    it->init();
            }
            void init() {…}
 
            void clean()
            {
                // Clean in reverse
                for (auto it = _pipes.rbegin(); it != _pipes.rend(); ++it)
                    (*it)->clean();
            }
            void clean() {…}
 
            Response run(const Request& request)
            {
                // Cannot use 'run' on an step-by-step pipe
                assert(!_last_step_pipe);
 
                if (_pipes.size() > 0)
                {
                #ifdef OE_UTIL_PIPELINE_RUN_BOTTOM_TO_TOP
                    return _pipes.back()->handle(request);
                #else
                    return _pipes.front()->handle(request);
                #endif
 
                }
 
                // No pipes, return default Response value
                return _default_response;
            }
            Response run(const Request& request) {…}
 
            Response getDefaultResponse() { return _default_response; }
 
            template<class... Types>
            void generateDefaultResponse(Types... args)
            {
                _default_response = {args...};
            }
            void generateDefaultResponse(Types... 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(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()
            {
            #ifdef OE_UTIL_PIPELINE_RUN_BOTTOM_TO_TOP
                PipeHandler* last_handler = _pipes.front();
                last_handler->_next_handler = _pipes.size() > 1
                    ? *(*(_pipes.begin()+1))
                    : nullptr
                ;
 
                for (auto it = _pipes.begin()+1; it != _pipes.end(); ++it)
            #else
                PipeHandler* last_handler = _pipes.back().get();
                last_handler->_next_handler = nullptr;
 
                for (auto it = _pipes.rbegin()+1; it != _pipes.rend(); ++it)
            #endif
                {
                    (*it)->_next_handler = last_handler;
                    last_handler = it->get();
                }
            }
    };
    class Pipeline {…};
}
 
#endif