ParallelExecutor.h

#pragma once

#include <queue>
#include <string>

#include <Poco/AtomicCounter.h>
#include <Poco/AutoPtr.h>
#include <Poco/Event.h>
#include <Poco/Mutex.h>
#include <Poco/RefCountedObject.h>
#include <Poco/Timespan.h>

#include "loop/StoppableLoop.h"
#include "util/AsyncExecutor.h"
#include "util/HavingThreadPool.h"

namespace BeeeOn {

class ParallelExecutor :
        public AsyncExecutor,
        public StoppableRunnable,
        public HavingThreadPool {
public:
        ParallelExecutor();
        ~ParallelExecutor();

        typedef Poco::SharedPtr<ParallelExecutor> Ptr;

        void setBaseName(const std::string &baseName);
        void setContentedDelay(const Poco::Timespan &delay);

        void run() override;

        void stop() override;

        size_t flushDeferred();

        void invoke(std::function<void()> f) override;

private:
        class ThreadLambda :
                public Poco::Runnable,
                public Poco::RefCountedObject,
                Loggable {
        public:
                typedef Poco::AutoPtr<ThreadLambda> Ptr;

                ThreadLambda(
                        std::function<void()> f,
                        Poco::Event &event,
                        const std::string &baseName);

                void start(Poco::ThreadPool &pool);
                void run() override;

        private:
                std::function<void()> m_func;
                Poco::Event &m_event;
                std::string m_baseName;
        };

        void defer(ThreadLambda::Ptr tl);

        void startOrDefer(ThreadLambda::Ptr tl);

private:
        std::string m_baseName;
        Poco::Timespan m_contentedDelay;
        std::queue<ThreadLambda::Ptr> m_queue;
        Poco::AtomicCounter m_stop;
        Poco::FastMutex m_lock;
        Poco::Event m_event;
};

}