scheduler.h

#pragma once
 
namespace resumef
{
    struct scheduler_t : public std::enable_shared_from_this<scheduler_t>
    {
    private:
        using state_sptr = counted_ptr<state_base_t>;
        using state_vector = std::vector<state_sptr>;
        using lock_type = spinlock;
        using task_dictionary_type = std::unordered_map<state_base_t*, std::unique_ptr<task_t>>;
 
        mutable spinlock _lock_running;
        state_vector _runing_states;
        state_vector _cached_states;
 
        mutable spinlock _lock_ready;
        task_dictionary_type _ready_task;
 
        timer_mgr_ptr _timer;
 
        task_t* new_task(task_t* task);
        //void cancel_all_task_();
    public:
        void run_one_batch();
 
        void run_until_notask();
 
        //void break_all();
 
        template<class _Ty
#ifndef DOXYGEN_SKIP_PROPERTY
            COMMA_RESUMEF_ENABLE_IF(traits::is_callable_v<_Ty> || traits::is_future_v<_Ty> || traits::is_generator_v<_Ty>)
#endif  //DOXYGEN_SKIP_PROPERTY
        >
#ifndef DOXYGEN_SKIP_PROPERTY
        RESUMEF_REQUIRES(traits::is_callable_v<_Ty> || traits::is_future_v<_Ty> || traits::is_generator_v<_Ty>)
#endif  //DOXYGEN_SKIP_PROPERTY
        task_t* operator + (_Ty&& coro)
        {
            if constexpr (traits::is_callable_v<_Ty>)
                return new_task(new task_ctx_impl_t<_Ty>(coro));
            else
                return new_task(new task_impl_t<_Ty>(coro));
        }
 
        bool empty() const
        {
            scoped_lock<spinlock, spinlock> __guard(_lock_ready, _lock_running);
            return _ready_task.empty() && _runing_states.empty() && _timer->empty();
        }
 
        timer_manager* timer() const noexcept
        {
            return _timer.get();
        }
 
#ifndef DOXYGEN_SKIP_PROPERTY
        void add_generator(state_base_t* sptr);
        void del_final(state_base_t* sptr);
        std::unique_ptr<task_t> del_switch(state_base_t* sptr);
        void add_switch(std::unique_ptr<task_t> task);
        task_t* find_task(state_base_t* sptr) const noexcept;
 
        friend struct local_scheduler_t;
    protected:
        scheduler_t();
    public:
        ~scheduler_t();
 
        scheduler_t(scheduler_t&& right_) = delete;
        scheduler_t& operator = (scheduler_t&& right_) = delete;
        scheduler_t(const scheduler_t&) = delete;
        scheduler_t& operator = (const scheduler_t&) = delete;
 
        static scheduler_t g_scheduler;
#endif  //DOXYGEN_SKIP_PROPERTY
    };
 
    struct local_scheduler_t
    {
        local_scheduler_t();
 
        local_scheduler_t(scheduler_t & sch);
 
        ~local_scheduler_t();
 
        local_scheduler_t(local_scheduler_t&& right_) = delete;
        local_scheduler_t& operator = (local_scheduler_t&& right_) = delete;
        local_scheduler_t(const local_scheduler_t&) = delete;
        local_scheduler_t& operator = (const local_scheduler_t&) = delete;
    private:
        scheduler_t* _scheduler_ptr;
    };
}