pipeline.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/buffer/producer.hxx>
#include <StormByte/buffer/typedefs.hxx>
 
#include <thread>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC Pipeline final {
        public:
            Pipeline() noexcept                                     = default;
 
            Pipeline(const Pipeline& other);
 
            Pipeline(Pipeline&& other) noexcept                     = default;
 
            ~Pipeline() noexcept;
 
            Pipeline& operator=(const Pipeline& other);
 
            Pipeline& operator=(Pipeline&& other) noexcept          = default;
 
            void                                                    AddPipe(const PipeFunction& pipe);
 
            void                                                    AddPipe(PipeFunction&& pipe);
 
            void                                                    SetError() const noexcept;
 
            Consumer                                                Process(Consumer buffer, const ExecutionMode& mode, std::shared_ptr<Logger::Log> log) const noexcept;
 
        private:
            std::vector<PipeFunction> m_pipes;                      
            mutable std::vector<Producer> m_producers;              
            mutable std::vector<std::thread> m_threads;             
 
            void                                                    WaitForCompletion() const noexcept;
    };
}