sequence_store.h

// DISCLAIMER_PLACEHOLDER
#pragma once
 
#include <cstdint>
#include <cstddef>
#include <string_view>
 
#include "../../core/os/memory_mapped_file.h"
#include "../../core/utilities/filesystem_utilities.h"
 
namespace llfix
{
 
class SequenceStore
{
    public:
 
        ~SequenceStore()
        {
            save_to_disc();
            m_memory_mapped_file.close();
        }
 
        bool open(const std::string_view& file_path)
        {
            auto folder = FileSystemUtilities::get_path_by_excluding_file(file_path);
 
            if (folder.length() > 0)
            {
                if (FileSystemUtilities::does_path_exist(folder) == false)
                {
                    if (FileSystemUtilities::create_directory(folder) == false)
                    {
                        return false;
                    }
                }
            }
 
            bool success = m_memory_mapped_file.open(file_path, MEMORY_MAPPED_FILE_SIZE);
 
            if (success)
            {
                m_buffer = nullptr;
                std::size_t buffer_size = 0;
                m_memory_mapped_file.get_buffer(&m_buffer, buffer_size);
            }
 
            return success;
        }
 
        bool is_open() const
        {
            return m_memory_mapped_file.is_open();
        }
 
        void save_to_disc()
        {
            if (m_memory_mapped_file.is_open())
            {
                m_memory_mapped_file.flush_to_disc();
            }
        }
 
        void reset_numbers()
        {
            set_outgoing_seq_no(0);
            set_incoming_seq_no(0);
        }
 
        // OUTGOING
        void increment_outgoing_seq_no()
        {
            reinterpret_cast<uint32_t*>(m_buffer)[0]++;
        }
 
        void decrement_outgoing_seq_no()
        {
            reinterpret_cast<uint32_t*>(m_buffer)[0]--;
        }
 
        void set_outgoing_seq_no(uint32_t n)
        {
            reinterpret_cast<uint32_t*>(m_buffer)[0] = n;
        }
 
        uint32_t get_outgoing_seq_no() const
        {
            return reinterpret_cast<uint32_t*>(m_buffer)[0];
        }
 
        // INCOMING
        void increment_incoming_seq_no()
        {
            reinterpret_cast<uint32_t*>(m_buffer)[1]++;
        }
 
        void set_incoming_seq_no(uint32_t n)
        {
            reinterpret_cast<uint32_t*>(m_buffer)[1] = n;
        }
 
        uint32_t get_incoming_seq_no() const
        {
            return reinterpret_cast<uint32_t*>(m_buffer)[1];
        }
 
    protected:
        MemoryMappedFile m_memory_mapped_file;
        char* m_buffer = nullptr;
        static inline constexpr std::size_t MEMORY_MAPPED_FILE_SIZE = 65536; // Even though a typical vm page is 4KB, on Windows page allocation granularity is 64KB
};
 
} // namespace