Storage.hpp

#pragma once
#include <boost/iterator/iterator_facade.hpp>
#include "creativity/state/StorageBackend.hpp"
#include <eris/types.hpp>
#include <algorithm>
#include <cstddef>
#include <memory>
#include <type_traits>
#include <vector>

namespace boost { namespace iterators { struct random_access_traversal_tag; } }

namespace creativity { struct CreativitySettings; }

namespace creativity { namespace state {

class Storage final {
    public:
        Storage() = delete;

        template<class SB, class... Args>
        static typename std::enable_if<std::is_base_of<StorageBackend, SB>::value, std::shared_ptr<Storage>>::type
        create(CreativitySettings &settings, Args&&... args) {
            return std::shared_ptr<Storage>(new Storage(settings, new SB(settings, std::forward<Args>(args)...)));
        }

        std::shared_ptr<const State> operator[](eris::eris_time_t t) const;

        size_t size() const;

        void reserve(size_t capacity);

        bool empty() const;

        void push_back(std::shared_ptr<const State> s);

        void updateSettings();

        const CreativitySettings& settings;

        template<class... Args>
        void emplace_back(Args&&... args);

        void flush(bool flush_buffers = true);

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

        StorageBackend& backend();

        bool flush_on_destroy = true;

        ~Storage();

        class state_iterator : public boost::iterator_facade<state_iterator, const std::shared_ptr<const State>, boost::random_access_traversal_tag> {
            private:
                const Storage *storage;
                size_t i = 0;
                std::shared_ptr<const State> curr;

                friend class Storage;
                friend class boost::iterator_core_access;

                state_iterator(const Storage &st, size_t at);

                reference dereference() const;
                void increment();
                void decrement();
                void advance(difference_type n);
                difference_type distance_to(const state_iterator &it) const;
                bool equal(const state_iterator &other) const;
        };

        state_iterator begin() const;
        state_iterator end() const;

    private:
        Storage(CreativitySettings &settings, StorageBackend *sb) : settings(settings), settings_(settings), backend_(sb)
        {
            // Track the number of states using the size of the cache_
            cache_.resize(backend_->size());
        }

        CreativitySettings &settings_;

        mutable std::vector<std::weak_ptr<const State>> cache_;

        mutable std::shared_ptr<const State> cache_last_;

        std::unique_ptr<StorageBackend> backend_;

        bool need_settings_updated_ = true;
};

template <class... Args>
void Storage::emplace_back(Args&&... args) {
    push_back(std::make_shared<State>(std::forward<Args>(args)...));
}

}}