coroutine.hpp

// By Emil Ernerfeldt 2014-2016
// LICENSE:
//   This software is dual-licensed to the public domain and under the following
//   license: you are granted a perpetual, irrevocable license to copy, modify,
//   publish, and distribute this file as you see fit.
// HISTORY
//   Originally made for Ghostel in 2014.

#pragma once

#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <string>
#include <vector>

namespace emilib {

namespace cr {

class InnerControl;

// ----------------------------------------------------------------------------

class Coroutine
{
public:
    Coroutine(const char* debug_name, std::function<void(InnerControl& ic)> fun);

    ~Coroutine();

    void stop();

    void poll(double dt);

    bool done() const { return _is_done; }

private:
    Coroutine(Coroutine&) = delete;
    Coroutine(Coroutine&&) = delete;
    Coroutine& operator=(Coroutine&) = delete;
    Coroutine& operator=(Coroutine&&) = delete;

    class Thread;
    friend class InnerControl;

    std::string                   _debug_name = "";
    std::unique_ptr<InnerControl> _inner;
    std::unique_ptr<Thread>       _thread;
    std::atomic<bool>             _is_done { false };
    std::mutex                    _mutex;
    std::condition_variable       _cond;
    std::atomic<bool>             _control_is_outer { true };
    std::atomic<bool>             _abort { false };
};


class InnerControl
{
public:
    InnerControl(Coroutine& cr) : _cr(cr) { }

    double time() const { return _time; }

    template<typename Fun>
    void wait_for(const Fun& fun)
    {
        while (!fun()) {
            yield();
        }
    }

    void wait_sec(double s);

    void yield();

    void poll(double dt);

private:
    Coroutine& _cr;
    double     _time = 0;
};

// ----------------------------------------------------------------------------

class CoroutineSet
{
public:
    bool   empty() const { return _list.empty(); }
    size_t size()  const { return _list.size();  }

    void clear();

    std::shared_ptr<Coroutine> start(const char* debug_name, std::function<void(InnerControl& ic)> fun);

    bool erase(const std::shared_ptr<Coroutine>& cr);

    void poll(double dt);

private:
    std::vector<std::shared_ptr<Coroutine>> _list;
};

} // namespace cr
} // namespace emilib