PendingSaves.h

#pragma once
 
#include <xrpl/protocol/Protocol.h>
 
#include <condition_variable>
#include <map>
#include <mutex>
 
namespace xrpl {

class PendingSaves
{
private:
    std::mutex mutable mutex_;
    std::map<LedgerIndex, bool> map_;
    std::condition_variable await_;
 
public:
    bool
    startWork(LedgerIndex seq)
    {
        std::scoped_lock const lock(mutex_);
 
        auto it = map_.find(seq);
 
        if ((it == map_.end()) || it->second)
        {
            // Work done or another thread is doing it
            return false;
        }
 
        it->second = true;
        return true;
    }

    void
    finishWork(LedgerIndex seq)
    {
        std::scoped_lock const lock(mutex_);
 
        map_.erase(seq);
        await_.notify_all();
    }

    bool
    pending(LedgerIndex seq)
    {
        std::scoped_lock const lock(mutex_);
        return map_.contains(seq);
    }

    bool
    shouldWork(LedgerIndex seq, bool isSynchronous)
    {
        std::unique_lock<std::mutex> lock(mutex_);
        do
        {
            auto it = map_.find(seq);
 
            if (it == map_.end())
            {
                map_.emplace(seq, false);
                return true;
            }
 
            if (!isSynchronous)
            {
                // Already dispatched
                return false;
            }
 
            if (!it->second)
            {
                // Scheduled, but not dispatched
                return true;
            }
 
            // Already in progress, just need to wait
            await_.wait(lock);
 
        } while (true);
    }

    std::map<LedgerIndex, bool>
    getSnapshot() const
    {
        std::scoped_lock const lock(mutex_);
 
        return map_;
    }
};
 
}  // namespace xrpl