FileStorage.hpp

#pragma once
#include "creativity/state/StorageBackend.hpp"
#include "creativity/BookCopy.hpp"
#include "creativity/CreativitySettings.hpp"
#include <eris/learning/BayesianLinearRestricted.hpp>
#include <eris/types.hpp>
#include <eris/serialize/serializer.hpp>
#include <eris/serialize/Serialization.hpp>
#include <Eigen/Core>
#include <boost/detail/endian.hpp>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <vector>
#include <iostream>
#include <memory>
#include <set>
#include <stdexcept>
#include <string>
#include <map>
#include <utility>

namespace creativity { namespace state {

class FileStorage : public StorageBackend, public eris::serialize::Serialization {
    public:
        enum TYPE : uint8_t {
            TYPE_DONE = 0, 
            TYPE_READERS = 1, 
            TYPE_BOOKS = 2, 
            TYPE_PUBLIC_TRACKER = 3 
        };

        FileStorage(CreativitySettings &settings) : StorageBackend(settings) {
            memory();
        }

        template <typename... Args>
        FileStorage(CreativitySettings &settings, const std::string &filename, Mode mode, Args&&... args)
        : StorageBackend(settings)
        {
            open(filename, mode, std::forward<Args>(args)...);
        }

        FileStorage(CreativitySettings &settings, std::unique_ptr<std::stringstream> &&s, Mode mode = Mode::READONLY);

        //FileStorage(FileStorage&&) = default;

        //FileStorage& operator=(FileStorage&&) = default;

        void throwParseError(const std::string& message) const;

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

        virtual size_t size() override;

        virtual void storage_flush() override;

    protected:

        void configureHeaderFields() override;

        void writeSettings() override;

        void writeExtraHeader() override;

        void readExtraHeader() override;

    private:

        uint64_t state_pointer_block_, readerlib_block_;

        // Sorting method that sorts by the library item's acquired date
        class lib_comp_less final {
            public:
                using ref = const std::pair<const eris::eris_id_t, BookCopy>&;
                bool operator()(ref a, ref b) const {
                    return a.second.acquired < b.second.acquired;
                }
        };

        // Reader library data
        struct lib_data {
            // book id to BookCopy
            std::map<uint64_t, BookCopy> library;
            // library, but sorted by acquired date (for fast retrieval)
            std::multiset<std::reference_wrapper<std::pair<const uint64_t, BookCopy>>, lib_comp_less> library_acq_sorted;
        };

        //id, the value is the pair of / the block location and the library data content.
        std::map<eris::eris_id_t, std::pair<uint64_t, lib_data>> reader_lib_;

        virtual uint32_t appFileVersion() const override { return 2; }

        virtual std::string appName() const override { return "creativity"; }

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

        void updateLibraries(const std::map<eris::eris_id_t, ReaderState> &r);

        std::shared_ptr<const State> readState();

        void writeState(const State &state);

        std::pair<eris::eris_id_t, ReaderState> readReader(eris::eris_time_t t);

        void writeReader(const ReaderState& reader);

        typedef struct {
            uint32_t K = 0; 
            bool noninformative = true; 
            Eigen::VectorXd beta; 
            double s2; 
            double n; 
            Eigen::MatrixXd Vinv; 
            eris::learning::BayesianLinearRestricted::DrawMode last_draw_mode; 
            uint32_t draw_success_cumulative, 
                     draw_discards_cumulative; 
        } belief_data;

        belief_data readBelief();

        void writeBelief(const eris::learning::BayesianLinear &belief);

        std::pair<eris::eris_id_t, BookState> readBook();

        void writeBook(const BookState &book);

        std::unique_ptr<PublicTrackerState> readPublicTracker();

        void writePublicTracker(const PublicTrackerState &pt);
};

}}