Journal.h

#pragma once

#include <list>
#include <set>
#include <string>

#include <Poco/File.h>
#include <Poco/Mutex.h>
#include <Poco/Nullable.h>
#include <Poco/Path.h>
#include <Poco/SharedPtr.h>

#include "util/Loggable.h"

namespace BeeeOn {

class Journal : protected virtual Loggable {
public:
        typedef Poco::SharedPtr<Journal> Ptr;

        struct Record {
                const std::string key;
                const std::string value;

                Record &operator =(const Record &other)
                {
                        const_cast<std::string&>(this->key) = other.key;
                        const_cast<std::string&>(this->value) = other.value;
                        return *this;
                }

                bool operator ==(const Record &other) const
                {
                        return key == other.key && value == other.value;
                }
        };

        Journal(
                const Poco::Path &file,
                double duplicatesFactor = 3,
                size_t minimalRewritesSize = 4096);
        virtual ~Journal();

        bool createEmpty();

        void checkExisting(bool regularFile = true, bool writable = true) const;

        void load(bool recover = false);

        void load(std::istream &in, bool recover = false);

        void checkConsistent() const;

        void checkConsistent(std::istream &in) const;

        void append(
                const std::string &key,
                const std::string &value,
                bool flush = true)
        {
                append({key, value}, flush);
        }

        void append(const Record &record, bool flush = true);

        void drop(const std::string &key, bool flush = true)
        {
                drop(std::set<std::string>{key}, flush);
        }

        void drop(const std::set<std::string> &keys, bool flush = true);

        void flush();

        std::list<Record> records() const;

        Poco::Nullable<std::string> operator [](const std::string &key) const;

        double currentDuplicatesFactor() const;

protected:
        void parseStream(std::istream &in, std::list<Record> &records) const;
        void parseStreamRecover(std::istream &in, std::list<Record> &records) const;
        void appendDrop(const std::string &key, bool flush);
        void dropInPlace(std::list<Record> &records, const std::string &key) const;

        double duplicatesFactor(const std::list<Record> &records) const;
        bool overMinimalSize() const;
        std::list<Record> recordsRaw() const;
        void interpret(std::list<Record> &records) const;
        void interpretAndFlush();
        void appendFlush();
        void rewriteAndFlush(const std::list<Record> &records);

        std::list<Record> &committed();
        std::list<Record> &dirty();

        void handleFailure(std::ostream &o) const;

        void checkRecord(const Record &record) const;
        std::string format(const Record &record, bool zeroSum = false) const;
        Record parse(const std::string &line, size_t lineno) const;
        size_t bytes(const std::list<Record> &records) const;

private:
        mutable Poco::Mutex m_lock;
        const Poco::File m_file;
        double m_duplicatesFactor;
        size_t m_minimalRewriteSize;
        std::list<Record> m_records;
        std::list<Record> m_dirty;
};

}