Class Executor

async_simple/Executor.h:72–195

class IOExecutor;

class Executor {
public:
    // Context is an identification for the context where an executor
    // should run. See checkin/checkout for details.
    using Context = void *;
    static constexpr Context NULLCTX = nullptr;

    // A time duration in microseconds.
    using Duration = std::chrono::duration<int64_t, std::micro>;

    // The schedulable function. Func should accept no argument and
    // return void.
    using Func = std::function<void()>;
    class TimeAwaitable;
    class TimeAwaiter;

    Executor(std::string name = "default") : _name(std::move(name)) {}
    virtual ~Executor() {}

    Executor(const Executor &) = delete;
    Executor &operator=(const Executor &) = delete;

    // Schedule a function.
    // `schedule` would return false if schedule failed, which means function
    // func will not be executed. In case schedule return true, the executor
    // should guarantee that the func would be executed.
    virtual bool schedule(Func func) = 0;

    // 4-bits priority, less level is more important. Default
    // value of async-simple schedule is DEFAULT. For scheduling level >=
    // YIELD, if executor always execute the work immediately if other
    // works, it may cause dead lock. are waiting.
    enum class Priority {
        HIGHEST = 0x0,
        DEFAULT = 0x7,
        YIELD = 0x8,
        LOWEST = 0xF
    };

    // Low 16-bit of schedule_info is reserved for async-simple, and the lowest
    // 4-bit is stand for priority level. The implementation of scheduling logic
    // isn't necessary, which is determined by implementation. However, to avoid
    // spinlock/yield deadlock, when priority level >= YIELD, scheduler
    // can't always execute the work immediately when other works are
    // waiting.
    virtual bool schedule(Func func, uint64_t schedule_info) {
        return schedule(std::move(func));
    }

    // Schedule a move only functor
    bool schedule_move_only(util::move_only_function<void()> func) {
        MoveWrapper<decltype(func)> tmp(std::move(func));
        return schedule([func = tmp]() { func.get()(); });
    }

    bool schedule_move_only(util::move_only_function<void()> func,
                            uint64_t schedule_info) {
        MoveWrapper<decltype(func)> tmp(std::move(func));