io_list.h

#pragma once
 
#include <boost/container/flat_map.hpp>
 
#include <condition_variable>
#include <cstddef>
#include <functional>
#include <memory>
#include <mutex>
#include <type_traits>
#include <utility>
 
namespace xrpl {

class IOList final
{
public:
    class Work
    {
        template <class = void>
        void
        destroy();
 
        friend class IOList;
        IOList* ios_ = nullptr;
 
    public:
        virtual ~Work()
        {
            destroy();
        }

        IOList&
        ios()
        {
            return *ios_;
        }
 
        virtual void
        close() = 0;
    };
 
private:
    template <class = void>
    void
    destroy();
 
    std::mutex m_;
    std::size_t n_ = 0;
    bool closed_ = false;
    std::condition_variable cv_;
    boost::container::flat_map<Work*, std::weak_ptr<Work>> map_;
    std::function<void(void)> f_;
 
public:
    IOList() = default;

    ~IOList()
    {
        destroy();
    }

    [[nodiscard]] bool
    closed() const
    {
        return closed_;
    }

    template <class T, class... Args>
    std::shared_ptr<T>
    emplace(Args&&... args);

    template <class Finisher>
    void
    close(Finisher&& f);
 
    void
    close()
    {
        close([] {});
    }

    template <class = void>
    void
    join();
};
 
//------------------------------------------------------------------------------
 
template <class>
void
IOList::Work::destroy()
{
    if (!ios_)
        return;
    std::function<void(void)> f;
    {
        std::scoped_lock const lock(ios_->m_);
        ios_->map_.erase(this);
        if (--ios_->n_ == 0 && ios_->closed_)
        {
            std::swap(f, ios_->f_);
            ios_->cv_.notify_all();
        }
    }
    if (f)
        f();
}
 
template <class>
void
IOList::destroy()
{
    close();
    join();
}
 
template <class T, class... Args>
std::shared_ptr<T>
IOList::emplace(Args&&... args)
{
    static_assert(std::is_base_of_v<Work, T>, "T must derive from IOList::Work");
    if (closed_)
        return nullptr;
    auto sp = std::make_shared<T>(std::forward<Args>(args)...);
    decltype(sp) dead;
 
    std::scoped_lock const lock(m_);
    if (!closed_)
    {
        ++n_;
        sp->Work::ios_ = this;
        map_.emplace(sp.get(), sp);
    }
    else
    {
        std::swap(sp, dead);
    }
    return sp;
}
 
template <class Finisher>
void
IOList::close(Finisher&& f)
{
    std::unique_lock<std::mutex> lock(m_);
    if (closed_)
        return;
    closed_ = true;
    auto map = std::move(map_);
    if (!map.empty())
    {
        f_ = std::forward<Finisher>(f);
        lock.unlock();
        for (auto const& p : map)
        {
            if (auto sp = p.second.lock())
                sp->close();
        }
    }
    else
    {
        lock.unlock();
        f();
    }
}
 
template <class>
void
IOList::join()
{
    std::unique_lock<std::mutex> lock(m_);
    cv_.wait(lock, [&] { return closed_ && n_ == 0; });
}
 
}  // namespace xrpl