CommonEventLoop.h

// -------------------------------------------------------------------------
#ifndef CommonEventLoop_H_
#define CommonEventLoop_H_
// -------------------------------------------------------------------------
#include <ev++.h>
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <queue>
#include <future>
// -------------------------------------------------------------------------
namespace uniset
{
 
 
    class EvWatcher
    {
        public:
            EvWatcher() {}
            virtual ~EvWatcher() {}
 
            // подготовка перед запуском loop:
            // запуск своих ev::xxx.start()
            virtual void evprepare( const ev::loop_ref& ) {}
 
            // действия при завершении:
            // вызов своих ev::xxx.stop()
            virtual void evfinish( const ev::loop_ref& ) {}
 
            virtual std::string wname() const noexcept
            {
                return "";
            }
    };
    // -------------------------------------------------------------------------
    class CommonEventLoop
    {
        public:
 
            CommonEventLoop() noexcept;
            ~CommonEventLoop();
 
            bool evIsActive() const noexcept;
 
            bool evrun( EvWatcher* w, size_t prepareTimeout_msec = 60000);
 
            bool async_evrun( EvWatcher* w, size_t prepareTimeout_msec = 60000 );
 
            bool evstop( EvWatcher* w );
 
            inline const ev::loop_ref evloop() noexcept
            {
                return loop;
            }
 
            // количество зарегистрированных wather-ов
            size_t size() const;
 
        protected:
 
        private:
 
            void onStop( ev::async& w, int revents ) noexcept;
            void onPrepare( ev::async& w, int revents ) noexcept;
            void defaultLoop() noexcept;
            bool runDefaultLoop( size_t waitTimeout_msec );
            bool activateWatcher( EvWatcher* w, size_t waitTimeout_msec );
            void onLoopOK( ev::timer& t, int revents ) noexcept;
 
            std::atomic_bool cancelled = { false };
            std::atomic_bool isrunning = { false };
 
            ev::dynamic_loop loop;
            ev::async evterm;
            std::unique_ptr<std::thread> thr;
            std::mutex              thr_mutex;
 
            std::mutex              term_mutex;
            std::condition_variable term_event;
            std::atomic_bool term_notify = { false };
 
            std::mutex wlist_mutex;
            std::vector<EvWatcher*> wlist;
 
            // готовящийся Watcher. Он может быть только один в единицу времени
            // это гарантирует prep_mutex
            EvWatcher* wprep = { nullptr };
            ev::async evprep;
            std::condition_variable prep_event;
            std::mutex              prep_mutex;
            std::atomic_bool prep_notify = { false };
 
 
            std::mutex              looprunOK_mutex;
            std::condition_variable looprunOK_event;
            ev::timer evruntimer;
    };
    // -------------------------------------------------------------------------
} // end of uniset namespace
// -------------------------------------------------------------------------
#endif // CommonEventLoop_H_
// -------------------------------------------------------------------------