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: 10.4.3
// joedbc compilation time: Jul 14 2026 13:07:22
// Generation of this file: 2026-07-14 11:07:28 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef settings_Database_declared
#define settings_Database_declared
 
#include "joedb/Freedom_Keeper.h"
#include "joedb/error/Exception.h"
#include "joedb/error/assert.h"
#include "joedb/get_version.h"
#include "joedb/hash_combine.h"
#include "ids.h"
 
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string_view>
 
 
static_assert(std::string_view(joedb::get_version()) == "10.4.3");
 
namespace settings
{
 /// @namespace settings
 ///
 /// Automatically generated by joedbc
 
 using joedb::Record_Id;
 using joedb::Table_Id;
 using joedb::Field_Id;
 
 class container_of_settings;
 
 
 namespace detail
 {
  struct data_of_settings
  {
   Field_Id current_field_id = Field_Id(0);
   std::vector<char> field_value_of_dark_mode;
   std::vector<std::string> field_value_of_host;
   std::vector<std::string> field_value_of_user;
 
   joedb::Freedom_Keeper freedom_keeper;
 
   size_t size() const {return freedom_keeper.size();}
 
   void resize(size_t new_size)
   {
    field_value_of_dark_mode.resize(new_size);
    field_value_of_host.resize(new_size);
    field_value_of_user.resize(new_size);
    freedom_keeper.resize(new_size);
   }
  };
 }
 
 
 /// Store all the tables of the database
 class Database
 {
  friend class Readable;
  friend class container_of_settings;
 
  public:
   template<typename E = joedb::Exception>
   static void throw_exception(std::string_view message)
   {
    std::string s("settings: ");
    s += message;
    throw E(s);
   }
 
   bool is_valid(id_of_settings id) const {return is_valid_record_id_for_settings(id.get_record_id());}
 
  protected:
   detail::data_of_settings storage_of_settings;
   bool is_valid_record_id_for_settings(Record_Id record_id) const {return storage_of_settings.freedom_keeper.is_used(record_id);}
 
   void internal_delete_settings(Record_Id record_id)
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record_id));
    storage_of_settings.field_value_of_dark_mode[to_underlying(record_id)] = 0;
    storage_of_settings.field_value_of_host[to_underlying(record_id)].clear();
    storage_of_settings.field_value_of_user[to_underlying(record_id)].clear();
    storage_of_settings.freedom_keeper.free(record_id);
   }
 
   void internal_insert_settings(Record_Id record_id)
   {
    storage_of_settings.freedom_keeper.use(record_id);
   }
 
   void internal_vector_insert_settings(Record_Id record_id, size_t size)
   {
    JOEDB_RELEASE_ASSERT(storage_of_settings.freedom_keeper.is_free_vector(record_id, size));
    storage_of_settings.freedom_keeper.use_vector(record_id, size);
   }
 
   void internal_update_settings__dark_mode
   (
    Record_Id record_id,
    bool field_value_of_dark_mode
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record_id));
    storage_of_settings.field_value_of_dark_mode[to_underlying(record_id)] = field_value_of_dark_mode;
   }
 
   void internal_update_vector_settings__dark_mode
   (
    Record_Id record_id,
    size_t size,
    const char *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_settings.freedom_keeper.is_used_vector(record_id, size));
    char *target = &storage_of_settings.field_value_of_dark_mode.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
   void internal_update_settings__host
   (
    Record_Id record_id,
    std::string_view field_value_of_host
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record_id));
    storage_of_settings.field_value_of_host[to_underlying(record_id)] = field_value_of_host;
   }
 
   void internal_update_vector_settings__host
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_settings.freedom_keeper.is_used_vector(record_id, size));
    std::string *target = &storage_of_settings.field_value_of_host.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
   void internal_update_settings__user
   (
    Record_Id record_id,
    std::string_view field_value_of_user
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record_id));
    storage_of_settings.field_value_of_user[to_underlying(record_id)] = field_value_of_user;
   }
 
   void internal_update_vector_settings__user
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_settings.freedom_keeper.is_used_vector(record_id, size));
    std::string *target = &storage_of_settings.field_value_of_user.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
  public:
   container_of_settings get_settings_table() const;
 
   id_of_settings next(id_of_settings id) const
   {
    return id_of_settings
    (
     Record_Id(storage_of_settings.freedom_keeper.get_next(id.get_record_id()))
    );
   }
 
   id_of_settings previous(id_of_settings id) const
   {
    return id_of_settings
    (
     Record_Id(storage_of_settings.freedom_keeper.get_previous(id.get_record_id()))
    );
   }
 
   static id_of_settings null_settings()
   {
    return id_of_settings();
   }
   static constexpr id_of_settings the_settings()
   {
    return id_of_settings{0};
   }
 
   bool get_dark_mode(id_of_settings record = id_of_settings{0}) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record.get_record_id()));
    return (bool)(storage_of_settings.field_value_of_dark_mode[record.get_id()]);
   }
 
   const std::string & get_host(id_of_settings record = id_of_settings{0}) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record.get_record_id()));
    return (const std::string &)(storage_of_settings.field_value_of_host[record.get_id()]);
   }
 
   const std::string & get_user(id_of_settings record = id_of_settings{0}) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_settings(record.get_record_id()));
    return (const std::string &)(storage_of_settings.field_value_of_user[record.get_id()]);
   }
 };
 /// returned by @ref Database::get_settings_table
 class container_of_settings
 {
  friend class Database;
 
  private:
   const Database &db;
   container_of_settings(const Database &db): db(db) {}
 
  public:
   class iterator
   {
    friend class container_of_settings;
    private:
     const joedb::Freedom_Keeper *fk;
     Record_Id index;
     iterator(const detail::data_of_settings &data): fk(&data.freedom_keeper), index(joedb::Freedom_Keeper_Constants::used_list) {}
    public:
     using iterator_category = std::forward_iterator_tag;
     using value_type = id_of_settings;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
     using reference = value_type&;
 
     bool operator==(const iterator &i) const {return index == i.index;}
     bool operator!=(const iterator &i) const {return index != i.index;}
     iterator &operator++() {index = fk->get_next(index); return *this;}
     iterator operator++(int) {auto copy = *this; index = fk->get_next(index); return copy;}
     iterator &operator--() {index = fk->get_previous(index); return *this;}
     iterator operator--(int) {auto copy = *this; index = fk->get_previous(index); return copy;}
     id_of_settings operator*() const {return id_of_settings(Record_Id(index));}
   };
 
   iterator begin() const {return ++iterator(db.storage_of_settings);}
   iterator end() const {return iterator(db.storage_of_settings);}
   bool is_empty() const {return db.storage_of_settings.freedom_keeper.get_used_count() == Record_Id{0};}
   joedb::index_t get_size() const {return to_underlying(db.storage_of_settings.freedom_keeper.get_used_count());}
   static id_of_settings get_at(size_t i) {return id_of_settings(Record_Id(i));}
   bool is_valid_at(size_t i) {return db.storage_of_settings.freedom_keeper.is_used(Record_Id(i));}
   id_of_settings first() const {return *begin();}
   id_of_settings last() const {return *--end();}
   id_of_settings get_end() const {return *end();}
 };
 
 inline container_of_settings Database::get_settings_table() const
 {
  return container_of_settings(*this);
 }
 
}
 
#endif