svf.h

Go to the documentation of this file.

 
#ifndef CPPSVF_SVF_H
#define CPPSVF_SVF_H
 
#include <string>
#include <vector>
#include <map>
#include <chrono>
#include <cassert>
 
#ifdef SVF_THREAD_SAFE
 
#include <mutex>
 
#endif
 
#ifdef DEBUG
#define SVF_ASSERT(x) assert(x)
#else
#define SVF_ASSERT(x)
#endif
 
namespace SVFS {
 
#pragma mark - Exceptions
 
    namespace Exceptions {
 
        class ExceptionSparseVirtualFile : public std::exception {
        public:
            explicit ExceptionSparseVirtualFile(const std::string &in_msg) : msg(in_msg) {}
 
            [[nodiscard]] const std::string &message() const { return msg; }
 
        protected:
            std::string msg;
        };
 
        class ExceptionSparseVirtualFileWrite : public ExceptionSparseVirtualFile {
        public:
            explicit ExceptionSparseVirtualFileWrite(const std::string &in_msg) : ExceptionSparseVirtualFile(in_msg) {}
        };
 
        class ExceptionSparseVirtualFileDiff : public ExceptionSparseVirtualFileWrite {
        public:
            explicit ExceptionSparseVirtualFileDiff(const std::string &in_msg) : ExceptionSparseVirtualFileWrite(
                    in_msg) {}
        };
 
        class ExceptionSparseVirtualFileRead : public ExceptionSparseVirtualFile {
        public:
            explicit ExceptionSparseVirtualFileRead(const std::string &in_msg) : ExceptionSparseVirtualFile(in_msg) {}
        };
 
        class ExceptionSparseVirtualFileErase : public ExceptionSparseVirtualFile {
        public:
            explicit ExceptionSparseVirtualFileErase(const std::string &in_msg) : ExceptionSparseVirtualFile(in_msg) {}
        };
 
    } // namespace Exceptions {
 
#pragma mark - typedefs
 
    typedef size_t t_fpos;
    typedef std::pair<t_fpos, size_t> t_seek_read;
    typedef std::vector<t_seek_read> t_seek_reads;
    typedef uint32_t t_block_touch;
    typedef std::map<t_block_touch, t_fpos> t_block_touches;
 
#pragma mark - SVF configuration
 
    typedef struct SparseVirtualFileConfig {
        bool overwrite_on_exit = false;
        bool compare_for_diff = true;
    } tSparseVirtualFileConfig;
 
#pragma mark - The SVF class
 
    class SparseVirtualFile {
    public:
        explicit SparseVirtualFile(const std::string &id, double mod_time,
                                   const tSparseVirtualFileConfig &config = tSparseVirtualFileConfig()) :
                m_id(id),
                m_file_mod_time(mod_time),
                m_config(config),
                m_bytes_total(0),
                m_count_write(0),
                m_count_read(0),
                m_bytes_write(0),
                m_bytes_read(0),
                m_time_write(std::chrono::time_point<std::chrono::system_clock>::min()),
                m_time_read(std::chrono::time_point<std::chrono::system_clock>::min()),
                m_block_touch(0),
                m_blocks_erased(0),
                m_bytes_erased(0),
                m_blocks_punted(0),
                m_bytes_punted(0) {
        }
 
        // ---- Read and write etc. ----
        [[nodiscard]] bool has(t_fpos fpos, size_t len) const noexcept;
 
        void write(t_fpos fpos, const char *data, size_t len);
 
        void read(t_fpos fpos, size_t len, char *p);
 
        [[nodiscard]] t_seek_reads need(t_fpos fpos, size_t len, size_t greedy_length = 0) const noexcept;
        [[nodiscard]] t_seek_reads need_many(t_seek_reads &seek_reads, size_t greedy_length = 0) const noexcept;
 
        void clear() noexcept;
 
        size_t erase(t_fpos fpos);
 
        // ---- Meta information about the SVF ----
        [[nodiscard]] t_seek_reads blocks() const noexcept;
 
        size_t block_size(t_fpos fpos) const;
 
        // Information about memory used:
        [[nodiscard]] size_t size_of() const noexcept;
 
        [[nodiscard]] size_t num_bytes() const noexcept { return m_bytes_total; };
 
        [[nodiscard]] size_t num_blocks() const noexcept { return m_svf.size(); }
 
        [[nodiscard]] t_fpos last_file_position() const noexcept;
 
        [[nodiscard]] bool file_mod_time_matches(const double &file_mod_time) const noexcept {
            return file_mod_time == m_file_mod_time;
        }
 
        // ---- Attribute access ----
        [[nodiscard]] const std::string &id() const noexcept { return m_id; }
 
        [[nodiscard]] double file_mod_time() const noexcept { return m_file_mod_time; }
 
        [[nodiscard]] const tSparseVirtualFileConfig &config() const noexcept { return m_config; }
 
        [[nodiscard]] size_t count_write() const noexcept { return m_count_write; }
 
        [[nodiscard]] size_t count_read() const noexcept { return m_count_read; }
 
        [[nodiscard]] size_t bytes_write() const noexcept { return m_bytes_write; }
 
        [[nodiscard]] size_t bytes_read() const noexcept { return m_bytes_read; }
 
        [[nodiscard]] size_t blocks_erased() const noexcept { return m_blocks_erased; }
        [[nodiscard]] size_t bytes_erased() const noexcept { return m_bytes_erased; }
        [[nodiscard]] size_t blocks_punted() const noexcept { return m_blocks_punted; }
        [[nodiscard]] size_t bytes_punted() const noexcept { return m_bytes_punted; }
 
        [[nodiscard]] std::chrono::time_point<std::chrono::system_clock> time_write() const noexcept {
            return m_time_write;
        }
 
        [[nodiscard]] std::chrono::time_point<std::chrono::system_clock> time_read() const noexcept {
            return m_time_read;
        }
 
        [[nodiscard]] t_block_touch block_touch() const noexcept { return m_block_touch; }
        [[nodiscard]] t_block_touches block_touches() const noexcept;
        size_t lru_punt(size_t cache_size_upper_bound);
 
        SparseVirtualFile(const SparseVirtualFile &rhs) = delete;
 
        SparseVirtualFile operator=(const SparseVirtualFile &rhs) = delete;
 
#ifdef SVF_THREAD_SAFE
 
        SparseVirtualFile(SparseVirtualFile &&other) = delete;
 
        SparseVirtualFile &operator=(SparseVirtualFile &&rhs) = delete;
 
#else
        SparseVirtualFile(SparseVirtualFile &&other) = default;
        SparseVirtualFile& operator=(SparseVirtualFile &&rhs) = default;
#endif
 
        ~SparseVirtualFile() { clear(); }
 
    private:
        std::string m_id;
        double m_file_mod_time;
        tSparseVirtualFileConfig m_config;
        size_t m_bytes_total = 0;
        size_t m_count_write = 0;
        size_t m_count_read = 0;
        size_t m_bytes_write = 0;
        size_t m_bytes_read = 0;
        std::chrono::time_point<std::chrono::system_clock> m_time_write;
        std::chrono::time_point<std::chrono::system_clock> m_time_read;
        typedef struct {
            std::vector<char> data;
            // Potentially more fields here such as time of access.
            t_block_touch block_touch;
        } t_val;
        typedef std::map<t_fpos, t_val> t_map;
        t_map m_svf;
        t_block_touch m_block_touch;
#ifdef SVF_THREAD_SAFE
        mutable std::mutex m_mutex;
#endif
        size_t m_blocks_erased;
        size_t m_bytes_erased;
        size_t m_blocks_punted;
        size_t m_bytes_punted;
    private:
        void _throw_diff(t_fpos fpos, const char *data, t_map::const_iterator iter, size_t index_iter) const;
 
        // Write data at file position without checks.
        void _write_new_block(t_fpos fpos, const char *data, size_t len, t_map::const_iterator hint);
 
        void _write_new_append_old(t_fpos fpos, const char *data, size_t len, t_map::iterator iter);
 
        void _write_append_new_to_old(t_fpos fpos, const char *new_data, size_t new_data_len,
                                      t_map::iterator base_block_iter);
 
        // Does not use mutex or checks integrity
        [[nodiscard]] t_fpos _file_position_immediatly_after_end() const noexcept;
 
        [[nodiscard]] t_fpos _file_position_immediatly_after_block(t_map::const_iterator iter) const noexcept;
 
        [[nodiscard]] static size_t _amount_to_read(t_seek_read iter, size_t greedy_length) noexcept;
 
        [[nodiscard]] static t_seek_reads
        _minimise_seek_reads(const t_seek_reads &seek_reads, size_t greedy_length) noexcept;
 
        [[nodiscard]] t_seek_reads _need_no_lock(t_fpos fpos, size_t len, size_t greedy_length = 0) const noexcept;
        [[nodiscard]] size_t _erase_no_lock(t_fpos fpos);
        [[nodiscard]] t_block_touches _block_touches_no_lock() const noexcept;
 
        enum ERROR_CONDITION {
            ERROR_NONE = 0,
            ERROR_EMPTY_BLOCK,
            ERROR_ADJACENT_BLOCKS,
            ERROR_BLOCKS_OVERLAP,
            ERROR_BYTE_COUNT_MISMATCH,
            ERROR_DUPLICATE_BLOCK,
            ERROR_DUPLICATE_BLOCK_TOUCH,
        };
 
        [[nodiscard]] ERROR_CONDITION integrity() const noexcept;
    };
 
} // namespace SVFS
 
#endif //CPPSVF_SVF_H