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/compcmake/gcc_debug/joedbc
// Version: 10.5.0
// joedbc compilation time: Oct 25 2026 16:06:59
// Generation of this file: 2026-10-25 19:48:05 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef tutorial_Writable_Database_declared
#define tutorial_Writable_Database_declared
 
#include "joedb/Span.h"
 
#include "Database_Writable.h"
 
#include <utility>
 
namespace tutorial
{
 namespace detail
 {
  class Client_Data;
 }
 
 class Client;
 class Multiplexer;
 class Memory_Database;
 
 /// A @ref Database that contains a @ref joedb::Writable_Journal and keeps them in sync
 class Writable_Database: public Database_Writable
 {
  friend class detail::Client_Data;
  friend class Client;
  friend class Multiplexer;
  friend class Memory_Database;
 
  private:
   joedb::Writable_Journal journal;
   bool ready_to_write;
 
   void play_journal();
   void auto_upgrade();
   void check_single_row();
   void initialize();
 
   Writable_Database
   (
    joedb::Abstract_File &file,
    joedb::Recovery recovery,
    bool perform_initialization
   );
 
  public:
   Writable_Database(joedb::Abstract_File &file);
 
   Writable_Database
   (
    joedb::Abstract_File &file,
    joedb::Recovery recovery
   );
 
   const joedb::Readonly_Journal &get_journal() const {return journal;}
 
   std::string read_blob(joedb::Blob blob) const
   {
    return journal.get_file().read_blob(blob);
   }
 
   joedb::Blob write_blob(std::string_view data) override
   {
    return journal.write_blob(data);
   }
 
   int64_t ahead_of_checkpoint() const
   {
    return journal.ahead_of_checkpoint();
   }
 
   void soft_checkpoint() override
   {
    journal.soft_checkpoint();
   }
 
   void hard_checkpoint() override
   {
    journal.hard_checkpoint();
   }
 
   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_city_table();
 
   id_of_city new_city()
   {
    id_of_city result(Record_Id(storage_of_city.freedom_keeper.get_free_record()));
    storage_of_city.resize(storage_of_city.freedom_keeper.size());
    internal_insert_city(result.get_record_id());
 
    journal.insert_into(Table_Id(1), result.get_record_id());
    return result;
   }
 
   void insert_city(id_of_city id)
   {
    if (id.get_record_id() >= Record_Id(storage_of_city.size()))
     storage_of_city.resize(id.get_id() + 1);
    internal_insert_city(id.get_record_id());
    journal.insert_into(Table_Id(1), id.get_record_id());
   }
 
   id_of_city new_vector_of_city(size_t size)
   {
    id_of_city result(Record_Id(storage_of_city.size()));
    storage_of_city.resize(storage_of_city.size() + size);
    internal_vector_insert_city(result.get_record_id(), size);
    journal.insert_vector(Table_Id(1), result.get_record_id(), size);
    return result;
   }
 
   id_of_city new_city
   (
    std::string field_value_of_name
   )
   {
    auto result = new_city();
    set_name(result, std::move(field_value_of_name));
    return result;
   }
 
   void delete_city(id_of_city record)
   {
    internal_delete_city(record.get_record_id());
    journal.delete_from(Table_Id(1), record.get_record_id());
   }
 
   void delete_vector_of_city(id_of_city v, size_t size)
   {
    for (size_t i = size; i > 0;)
     internal_delete_city(v[--i].get_record_id());
    journal.delete_vector(Table_Id(1), v.get_record_id(), size);
   }
 
   void set_name(id_of_city record, std::string field_value_of_name)
   {
    internal_update_city__name(record.get_record_id(), std::move(field_value_of_name));
    journal.update_string(Table_Id(1), record.get_record_id(), Field_Id(1), get_name(record));
   }
 
   template<typename F> void update_vector_of_name(id_of_city record, size_t size, F f)
   {
    JOEDB_DEBUG_ASSERT(storage_of_city.freedom_keeper.is_used_vector(record.get_record_id(), size));
    joedb::Span<std::string> span(&storage_of_city.field_value_of_name.data()[record.get_id()], size);
    f(span);
    internal_update_vector_city__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()));
   }
 
 
   void clear_person_table();
 
   id_of_person new_person()
   {
    id_of_person result(Record_Id(storage_of_person.freedom_keeper.get_free_record()));
    storage_of_person.resize(storage_of_person.freedom_keeper.size());
    internal_insert_person(result.get_record_id());
 
    journal.insert_into(Table_Id(2), result.get_record_id());
    return result;
   }
 
   void insert_person(id_of_person id)
   {
    if (id.get_record_id() >= Record_Id(storage_of_person.size()))
     storage_of_person.resize(id.get_id() + 1);
    internal_insert_person(id.get_record_id());
    journal.insert_into(Table_Id(2), id.get_record_id());
   }
 
   id_of_person new_vector_of_person(size_t size)
   {
    id_of_person result(Record_Id(storage_of_person.size()));
    storage_of_person.resize(storage_of_person.size() + size);
    internal_vector_insert_person(result.get_record_id(), size);
    journal.insert_vector(Table_Id(2), result.get_record_id(), size);
    return result;
   }
 
   id_of_person new_person
   (
    std::string field_value_of_first_name,
    std::string field_value_of_last_name,
    id_of_city field_value_of_home
   )
   {
    auto result = new_person();
    set_first_name(result, std::move(field_value_of_first_name));
    set_last_name(result, std::move(field_value_of_last_name));
    set_home(result, field_value_of_home);
    return result;
   }
 
   void delete_person(id_of_person record)
   {
    internal_delete_person(record.get_record_id());
    journal.delete_from(Table_Id(2), record.get_record_id());
   }
 
   void delete_vector_of_person(id_of_person v, size_t size)
   {
    for (size_t i = size; i > 0;)
     internal_delete_person(v[--i].get_record_id());
    journal.delete_vector(Table_Id(2), v.get_record_id(), size);
   }
 
   void set_first_name(id_of_person record, std::string field_value_of_first_name)
   {
    internal_update_person__first_name(record.get_record_id(), std::move(field_value_of_first_name));
    journal.update_string(Table_Id(2), record.get_record_id(), Field_Id(1), get_first_name(record));
   }
 
   template<typename F> void update_vector_of_first_name(id_of_person record, size_t size, F f)
   {
    JOEDB_DEBUG_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record.get_record_id(), size));
    joedb::Span<std::string> span(&storage_of_person.field_value_of_first_name.data()[record.get_id()], size);
    f(span);
    internal_update_vector_person__first_name(record.get_record_id(), size, span.begin());
    journal.update_vector_string(Table_Id(2), record.get_record_id(), Field_Id(1), size, (span.begin()));
   }
 
   void set_last_name(id_of_person record, std::string field_value_of_last_name)
   {
    internal_update_person__last_name(record.get_record_id(), std::move(field_value_of_last_name));
    journal.update_string(Table_Id(2), record.get_record_id(), Field_Id(2), get_last_name(record));
   }
 
   template<typename F> void update_vector_of_last_name(id_of_person record, size_t size, F f)
   {
    JOEDB_DEBUG_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record.get_record_id(), size));
    joedb::Span<std::string> span(&storage_of_person.field_value_of_last_name.data()[record.get_id()], size);
    f(span);
    internal_update_vector_person__last_name(record.get_record_id(), size, span.begin());
    journal.update_vector_string(Table_Id(2), record.get_record_id(), Field_Id(2), size, (span.begin()));
   }
 
   void set_home(id_of_person record, id_of_city field_value_of_home)
   {
    internal_update_person__home(record.get_record_id(), field_value_of_home);
    journal.update_reference(Table_Id(2), record.get_record_id(), Field_Id(3), field_value_of_home.get_record_id());
   }
 
   template<typename F> void update_vector_of_home(id_of_person record, size_t size, F f)
   {
    JOEDB_DEBUG_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record.get_record_id(), size));
    joedb::Span<id_of_city> span(&storage_of_person.field_value_of_home.data()[record.get_id()], size);
    f(span);
    internal_update_vector_person__home(record.get_record_id(), size, span.begin());
    journal.update_vector_reference(Table_Id(2), record.get_record_id(), Field_Id(3), size, reinterpret_cast<Record_Id *>(span.begin()));
   }
 
 
 };}
 
#endif