PersistLog.hpp

Go to the documentation of this file.

#ifndef PERSIST_LOG_HPP
#define PERSIST_LOG_HPP

#if !defined(__GNUG__) && !defined(__clang__)
#error PersistLog.hpp only works with clang and gnu compilers
#endif

#include "../HLC.hpp"
#include "../PersistException.hpp"
#include "../PersistentTypenames.hpp"
#include <functional>
#include <inttypes.h>
#include <map>
#include <set>
#include <stdio.h>
#include <string>

namespace persistent {

// Storage type:
enum StorageType {
    ST_FILE = 0,
    ST_MEM,
    ST_3DXP
};

//#define INVALID_VERSION ((__int128)-1L)
#define INVALID_VERSION ((int64_t)-1L)
#define INVALID_INDEX INT64_MAX

// index entry for the hlc index
struct hlc_index_entry {
    HLC hlc;
    int64_t log_idx;
    //default constructor
    hlc_index_entry() : log_idx(-1) {
    }
    // constructor with hlc and index.
    hlc_index_entry(const HLC &_hlc, const int64_t &_log_idx) : hlc(_hlc), log_idx(_log_idx) {
    }
    // constructor with time stamp and index.
    hlc_index_entry(const uint64_t &r, const uint64_t &l, const int64_t &_log_idx) : hlc(r, l), log_idx(_log_idx) {
    }
    //copy constructor
    hlc_index_entry(const struct hlc_index_entry &_entry) : hlc(_entry.hlc), log_idx(_entry.log_idx) {
    }
};
// comparator for the hlc index
struct hlc_index_entry_comp {
    bool operator()(const struct hlc_index_entry &e1,
                    const struct hlc_index_entry &e2) const {
        return e1.hlc < e2.hlc;
    }
};

// Persistent log interfaces
class PersistLog {
public:
    // LogName
    const std::string m_sName;
    // HLCIndex
    std::set<hlc_index_entry, hlc_index_entry_comp> hidx;
#ifdef DERECHO_DEBUG
    void dump_hidx();
#endif  //DERECHO_DEBUG
    // Constructor:
    // Remark: the constructor will check the persistent storage
    // to make sure if this named log(by "name" in the template
    // parameters) is already there. If it is, load it from disk.
    // Otherwise, create the log.
    PersistLog(const std::string &name) noexcept(true);
    virtual ~PersistLog() noexcept(true);
    virtual void append(const void *pdata,
                        const uint64_t &size, const version_t &ver,  
                        const HLC &mhlc) noexcept(false)
            = 0;

    // virtual void advanceVersion(const __int128 & ver) noexcept(false) = 0;
    virtual void advanceVersion(const version_t &ver) noexcept(false) = 0;

    // Get the length of the log
    virtual int64_t getLength() noexcept(false) = 0;

    // Get the Earliest Index
    virtual int64_t getEarliestIndex() noexcept(false) = 0;

    // Get the Latest Index
    virtual int64_t getLatestIndex() noexcept(false) = 0;

    // Get the Index corresponding to a version
    virtual int64_t getVersionIndex(const version_t &ver) noexcept(false) = 0;

    // Get the Index corresponding to an HLC timestamp
    virtual int64_t getHLCIndex(const HLC& hlc) noexcept(false) = 0;

    // Get the Earlist version
    virtual version_t getEarliestVersion() noexcept(false) = 0;

    // Get the Latest version
    virtual version_t getLatestVersion() noexcept(false) = 0;

    // return the last persisted value
    virtual const version_t getLastPersisted() noexcept(false) = 0;

    // Get a version by entry number return both length and buffer
    virtual const void *getEntryByIndex(const int64_t &eno) noexcept(false) = 0;

    // Get the latest version equal or earlier than ver.
    virtual const void *getEntry(const version_t &ver) noexcept(false) = 0;

    // Get the latest version - deprecated.
    // virtual const void* getEntry() noexcept(false) = 0;
    // Get a version specified by hlc
    virtual const void *getEntry(const HLC &hlc) noexcept(false) = 0;

    virtual const version_t persist(const bool preLocked = false) noexcept(false) = 0;

    virtual void trimByIndex(const int64_t &idx) noexcept(false) = 0;

    virtual void trim(const version_t &ver) noexcept(false) = 0;

    virtual void trim(const HLC &hlc) noexcept(false) = 0;

    virtual size_t bytes_size(const version_t &ver) = 0;

    virtual size_t to_bytes(char *buf, const version_t &ver) = 0;

    virtual void post_object(const std::function<void(char const *const, std::size_t)> &f,
                             const version_t &ver)
            = 0;

    virtual void applyLogTail(char const *v) = 0;

    virtual void truncate(const version_t &ver) noexcept(false) = 0;
};
}

#endif  //PERSIST_LOG_HPP