StorageBackend.hpp

#pragma once
#include <queue>
#include <condition_variable>
#include <cstddef>
#include <eris/types.hpp>
#include <memory>
#include <mutex>
#include <thread>
#include <eris/noncopyable.hpp>
#include "creativity/state/State.hpp"

namespace creativity { struct CreativitySettings; }

namespace creativity { namespace state {

class StorageBackend : private eris::noncopyable {
    public:
        StorageBackend(CreativitySettings &settings) : settings_{settings} {}

        virtual size_t size() = 0;

        bool empty();

        virtual void reserve(size_t T);

        virtual void writeSettings() = 0;

        void flush(bool flush_buffers = true);

        bool flush_for(long milliseconds, bool flush_buffers = true);

        virtual void enqueue(std::shared_ptr<const State> &&s);

        virtual size_t pending() const;

        virtual std::shared_ptr<const State> load(eris::eris_time_t t) = 0;

        virtual ~StorageBackend();

    protected:
        virtual void thread_insert(std::shared_ptr<const State> &&s);

        virtual void storage_flush();

        CreativitySettings &settings_;

    private:

        std::queue<std::shared_ptr<const State>> queue_;

        unsigned queue_pending_ = 0;

        bool flush_pending_ = false;

        mutable std::mutex queue_mutex_;

        std::condition_variable queue_cv_;

        std::condition_variable queue_finished_cv_;

        std::thread thread_;

        bool thread_quit_ = false;

        void thread_loop_();

};

}}