Writable_Database.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
//
// This code was automatically generated by the joedb compiler
// https://www.joedb.org/
//
// Path to compiler: /home/rcoulom/repos/joedb/doc/source/tutorial/build/joedbc
// Version: 9.1.4
// joedbc compilation time: Apr 15 2025 14:46:29
// Generation of this file: 2025-04-15 12:46:31 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef joedb_db_multi_server_Writable_Database_declared
#define joedb_db_multi_server_Writable_Database_declared
 
#include "Database.h"
#include "joedb/Span.h"
 
namespace joedb::db::multi_server
{
 namespace detail
 {
  class Client_Data;
 }
 
 class Client;
 class Multiplexer;
 
 /// A writable @ref Database constructed from a writable @ref joedb::Buffered_File
 class Writable_Database: public Database
 {
  friend class detail::Client_Data;
  friend class Client;
  friend class Multiplexer;
 
  private:
   joedb::Writable_Journal journal;
   bool ready_to_write;
 
   void play_journal();
   void auto_upgrade();
   void check_single_row();
 
   void initialize()
   {
    play_journal();
    check_schema();
    auto_upgrade();
    check_single_row();
    default_checkpoint();
   }
 
   Writable_Database
   (
    joedb::Buffered_File &file,
    bool perform_initialization,
    joedb::Readonly_Journal::Check check,
    joedb::Commit_Level commit_level
   );
 
  public:
   Writable_Database
   (
    joedb::Buffered_File &file,
    joedb::Readonly_Journal::Check check = joedb::Readonly_Journal::Check::all,
    joedb::Commit_Level commit_level = joedb::Commit_Level::no_commit
   );
 
   const joedb::Readonly_Journal &get_journal() const {return journal;}
 
   std::string read_blob_data(joedb::Blob blob) const
   {
    return journal.get_file().read_blob_data(blob);
   }
 
   joedb::Blob write_blob_data(const std::string &data) final
   {
    return journal.write_blob_data(data);
   }
 
   int64_t ahead_of_checkpoint() const
   {
    return journal.ahead_of_checkpoint();
   }
 
   void checkpoint_no_commit()
   {
    journal.checkpoint(joedb::Commit_Level::no_commit);
   }
 
   void checkpoint_half_commit()
   {
    journal.checkpoint(joedb::Commit_Level::half_commit);
   }
 
   void checkpoint_full_commit()
   {
    journal.checkpoint(joedb::Commit_Level::full_commit);
   }
 
   void checkpoint()
   {
    journal.default_checkpoint();
   }
 
   void checkpoint(joedb::Commit_Level commit_level) final
   {
    journal.checkpoint(commit_level);
   }
 
   void write_comment(const std::string &comment);
   void write_timestamp();
   void write_timestamp(int64_t timestamp);
   void write_valid_data();
   void flush() override {journal.flush();}
 
   void clear_server_table();
 
   id_of_server new_server()
   {
    id_of_server result(Record_Id(storage_of_server.freedom_keeper.get_free_record() - 1));
    storage_of_server.resize(storage_of_server.freedom_keeper.size());
    internal_insert_server(result.get_record_id());
 
    journal.insert_into(Table_Id(1), result.get_record_id());
    return result;
   }
 
   id_of_server new_vector_of_server(size_t size)
   {
    id_of_server result(Record_Id(storage_of_server.size() + 1));
    storage_of_server.resize(storage_of_server.size() + size);
    internal_vector_insert_server(result.get_record_id(), size);
    journal.insert_vector(Table_Id(1), result.get_record_id(), size);
    return result;
   }
 
   id_of_server new_server
   (
    const std::string& field_value_of_file_name,
    int32_t field_value_of_port,
    int32_t field_value_of_timeout
   )
   {
    auto result = new_server();
    set_file_name(result, field_value_of_file_name);
    set_port(result, field_value_of_port);
    set_timeout(result, field_value_of_timeout);
    return result;
   }
 
   void delete_server(id_of_server record)
   {
    internal_delete_server(record.get_record_id());
    journal.delete_from(Table_Id(1), record.get_record_id());
   }
 
   void delete_vector_of_server(id_of_server v, size_t size)
   {
    for (size_t i = size; i > 0;)
     delete_server(v[--i]);
   }
 
   void set_file_name(id_of_server record, const std::string& field_value_of_file_name)
   {
    internal_update_server__file_name(record.get_record_id(), field_value_of_file_name);
    journal.update_string(Table_Id(1), record.get_record_id(), Field_Id(1), field_value_of_file_name);
   }
 
   template<typename F> void update_vector_of_file_name(id_of_server record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<std::string> span(&storage_of_server.field_value_of_file_name[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_server__file_name(record.get_record_id(), size, span.begin());
    journal.update_vector_string(Table_Id(1), record.get_record_id(), Field_Id(1), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
   void set_port(id_of_server record, int32_t field_value_of_port)
   {
    internal_update_server__port(record.get_record_id(), field_value_of_port);
    journal.update_int32(Table_Id(1), record.get_record_id(), Field_Id(2), field_value_of_port);
   }
 
   template<typename F> void update_vector_of_port(id_of_server record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<int32_t> span(&storage_of_server.field_value_of_port[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_server__port(record.get_record_id(), size, span.begin());
    journal.update_vector_int32(Table_Id(1), record.get_record_id(), Field_Id(2), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
   void set_timeout(id_of_server record, int32_t field_value_of_timeout)
   {
    internal_update_server__timeout(record.get_record_id(), field_value_of_timeout);
    journal.update_int32(Table_Id(1), record.get_record_id(), Field_Id(3), field_value_of_timeout);
   }
 
   template<typename F> void update_vector_of_timeout(id_of_server record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<int32_t> span(&storage_of_server.field_value_of_timeout[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_server__timeout(record.get_record_id(), size, span.begin());
    journal.update_vector_int32(Table_Id(1), record.get_record_id(), Field_Id(3), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
 
 };}
 
#endif