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.2.1
// joedbc compilation time: Sep 15 2025 20:22:33
// Generation of this file: 2025-09-15 18:23:01 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef tutorial_Database_declared
#define tutorial_Database_declared
 
#include "joedb/Freedom_Keeper.h"
#include "joedb/error/Exception.h"
#include "joedb/error/assert.h"
#include "joedb/get_version.h"
#include "ids.h"
 
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string_view>
 
#include "joedb/ui/type_io.h"
#include <sstream>
#include <map>
 
static_assert(std::string_view(joedb::get_version()) == "10.2.1");
 
namespace tutorial
{
 /// @namespace tutorial
 ///
 /// Automatically generated by joedbc
 
 using joedb::Record_Id;
 using joedb::Table_Id;
 using joedb::Field_Id;
 
 class container_of_city;
 class container_of_person;
 
 namespace detail
 {
  struct data_of_city
  {
   std::vector<std::string> field_value_of_name;
   std::vector<std::map<std::string, id_of_city>::iterator> iterator_over_city_by_name;
 
   joedb::Freedom_Keeper freedom_keeper;
 
   size_t size() const {return freedom_keeper.size();}
 
   void resize(size_t new_size)
   {
    field_value_of_name.resize(new_size);
    iterator_over_city_by_name.resize(new_size);
    freedom_keeper.resize(new_size);
   }
  };
 
  struct data_of_person
  {
   std::vector<std::string> field_value_of_first_name;
   std::vector<std::string> field_value_of_last_name;
   std::vector<id_of_city> field_value_of_home;
   std::vector<std::multimap<std::tuple<std::string, std::string>, id_of_person>::iterator> iterator_over_person_by_name;
 
   joedb::Freedom_Keeper freedom_keeper;
 
   size_t size() const {return freedom_keeper.size();}
 
   void resize(size_t new_size)
   {
    field_value_of_first_name.resize(new_size);
    field_value_of_last_name.resize(new_size);
    field_value_of_home.resize(new_size);
    iterator_over_person_by_name.resize(new_size);
    freedom_keeper.resize(new_size);
   }
  };
 }
 
 class range_of_person_by_name;
 
 /// Store all the tables of the database
 class Database
 {
  friend class Readable;
  friend class container_of_city;
  friend class container_of_person;
  friend class range_of_person_by_name;
 
  public:
   template<typename E = joedb::Exception>
   static void throw_exception(const std::string &message)
   {
    throw E("tutorial: " + message);
   }
 
   bool is_valid(id_of_city id) const {return is_valid_record_id_for_city(id.get_record_id());}
   bool is_valid(id_of_person id) const {return is_valid_record_id_for_person(id.get_record_id());}
 
  protected:
   detail::data_of_city storage_of_city;
   bool is_valid_record_id_for_city(Record_Id record_id) const {return storage_of_city.freedom_keeper.is_used(record_id);}
   detail::data_of_person storage_of_person;
   bool is_valid_record_id_for_person(Record_Id record_id) const {return storage_of_person.freedom_keeper.is_used(record_id);}
 
   std::map<std::string, id_of_city> index_of_city_by_name;
   void remove_index_of_city_by_name(Record_Id record_id)
   {
    auto &iterator = storage_of_city.iterator_over_city_by_name[to_underlying(record_id)];
    if (iterator != index_of_city_by_name.end())
    {
     index_of_city_by_name.erase(iterator);
     iterator = index_of_city_by_name.end();
    }
   }
   void add_index_of_city_by_name(Record_Id record_id)
   {
    auto result = index_of_city_by_name.insert
    (
     std::map<std::string, id_of_city>::value_type
     (
      (storage_of_city.field_value_of_name[to_underlying(record_id)]),
      id_of_city(record_id)
     )
    );
    if (!result.second)
    {
     std::ostringstream out;
     out << "city_by_name unique index failure: (";
     joedb::write_string(out, storage_of_city.field_value_of_name[to_underlying(record_id)]);
     out << ") at id = " << record_id << ' ';
     out << "was already at id = " << result.first->second.get_id();
     throw_exception(out.str());
    }
    storage_of_city.iterator_over_city_by_name[to_underlying(record_id)] = result.first;
   }
   std::multimap<std::tuple<std::string, std::string>, id_of_person> index_of_person_by_name;
   void remove_index_of_person_by_name(Record_Id record_id)
   {
    auto &iterator = storage_of_person.iterator_over_person_by_name[to_underlying(record_id)];
    if (iterator != index_of_person_by_name.end())
    {
     index_of_person_by_name.erase(iterator);
     iterator = index_of_person_by_name.end();
    }
   }
   void add_index_of_person_by_name(Record_Id record_id)
   {
    auto result = index_of_person_by_name.insert
    (
     std::multimap<std::tuple<std::string, std::string>, id_of_person>::value_type
     (
      std::tuple<std::string, std::string>(storage_of_person.field_value_of_last_name[to_underlying(record_id)], storage_of_person.field_value_of_first_name[to_underlying(record_id)]),
      id_of_person(record_id)
     )
    );
    storage_of_person.iterator_over_person_by_name[to_underlying(record_id)] = result;
   }
 
   void internal_delete_city(Record_Id record_id)
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_city(record_id));
    remove_index_of_city_by_name(record_id);
    storage_of_city.field_value_of_name[to_underlying(record_id)].clear();
    storage_of_city.freedom_keeper.free(record_id);
   }
   void internal_delete_person(Record_Id record_id)
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record_id));
    remove_index_of_person_by_name(record_id);
    storage_of_person.field_value_of_first_name[to_underlying(record_id)].clear();
    storage_of_person.field_value_of_last_name[to_underlying(record_id)].clear();
    storage_of_person.field_value_of_home[to_underlying(record_id)] = id_of_city(joedb::Record_Id::null);
    storage_of_person.freedom_keeper.free(record_id);
   }
 
   void internal_insert_city(Record_Id record_id)
   {
    storage_of_city.iterator_over_city_by_name[to_underlying(record_id)] = index_of_city_by_name.end();
    storage_of_city.freedom_keeper.use(record_id);
   }
 
   void internal_vector_insert_city(Record_Id record_id, size_t size)
   {
    JOEDB_RELEASE_ASSERT(storage_of_city.freedom_keeper.is_free_vector(record_id, size));
    storage_of_city.freedom_keeper.use_vector(record_id, size);
    std::fill_n
    (
     &storage_of_city.iterator_over_city_by_name[to_underlying(record_id)],
     size,
     index_of_city_by_name.end()
    );
   }
   void internal_insert_person(Record_Id record_id)
   {
    storage_of_person.iterator_over_person_by_name[to_underlying(record_id)] = index_of_person_by_name.end();
    storage_of_person.freedom_keeper.use(record_id);
   }
 
   void internal_vector_insert_person(Record_Id record_id, size_t size)
   {
    JOEDB_RELEASE_ASSERT(storage_of_person.freedom_keeper.is_free_vector(record_id, size));
    storage_of_person.freedom_keeper.use_vector(record_id, size);
    std::fill_n
    (
     &storage_of_person.iterator_over_person_by_name[to_underlying(record_id)],
     size,
     index_of_person_by_name.end()
    );
   }
 
   void internal_update_city__name
   (
    Record_Id record_id,
    const std::string& field_value_of_name
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_city(record_id));
    storage_of_city.field_value_of_name[to_underlying(record_id)] = field_value_of_name;
    remove_index_of_city_by_name(record_id);
    add_index_of_city_by_name(record_id);
   }
 
   void internal_update_vector_city__name
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_city.freedom_keeper.is_used_vector(record_id, size));
    std::string *target = &storage_of_city.field_value_of_name.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
    for (size_t i = 0; i < size; i++)
     remove_index_of_city_by_name(record_id + i);
    for (size_t i = 0; i < size; i++)
     add_index_of_city_by_name(record_id + i);
   }
 
   void internal_update_person__first_name
   (
    Record_Id record_id,
    const std::string& field_value_of_first_name
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record_id));
    storage_of_person.field_value_of_first_name[to_underlying(record_id)] = field_value_of_first_name;
    remove_index_of_person_by_name(record_id);
    add_index_of_person_by_name(record_id);
   }
 
   void internal_update_vector_person__first_name
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record_id, size));
    std::string *target = &storage_of_person.field_value_of_first_name.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
    for (size_t i = 0; i < size; i++)
     remove_index_of_person_by_name(record_id + i);
    for (size_t i = 0; i < size; i++)
     add_index_of_person_by_name(record_id + i);
   }
 
   void internal_update_person__last_name
   (
    Record_Id record_id,
    const std::string& field_value_of_last_name
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record_id));
    storage_of_person.field_value_of_last_name[to_underlying(record_id)] = field_value_of_last_name;
    remove_index_of_person_by_name(record_id);
    add_index_of_person_by_name(record_id);
   }
 
   void internal_update_vector_person__last_name
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record_id, size));
    std::string *target = &storage_of_person.field_value_of_last_name.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
    for (size_t i = 0; i < size; i++)
     remove_index_of_person_by_name(record_id + i);
    for (size_t i = 0; i < size; i++)
     add_index_of_person_by_name(record_id + i);
   }
 
   void internal_update_person__home
   (
    Record_Id record_id,
    id_of_city field_value_of_home
   )
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record_id));
    storage_of_person.field_value_of_home[to_underlying(record_id)] = field_value_of_home;
   }
 
   void internal_update_vector_person__home
   (
    Record_Id record_id,
    size_t size,
    const id_of_city *value
   )
   {
    JOEDB_RELEASE_ASSERT(storage_of_person.freedom_keeper.is_used_vector(record_id, size));
    id_of_city *target = &storage_of_person.field_value_of_home.data()[to_underlying(record_id)];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
  public:
   container_of_city get_city_table() const;
 
   id_of_city next(id_of_city id) const
   {
    return id_of_city
    (
     Record_Id(storage_of_city.freedom_keeper.get_next(id.get_record_id()))
    );
   }
 
   id_of_city previous(id_of_city id) const
   {
    return id_of_city
    (
     Record_Id(storage_of_city.freedom_keeper.get_previous(id.get_record_id()))
    );
   }
 
   template<class Comparator>
   std::vector<id_of_city> sorted_city(Comparator comparator) const;
 
   static id_of_city null_city()
   {
    return id_of_city();
   }
 
   const std::string& get_name(id_of_city record) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_city(record.get_record_id()));
    return (const std::string&)(storage_of_city.field_value_of_name[record.get_id()]);
   }
 
   container_of_person get_person_table() const;
 
   id_of_person next(id_of_person id) const
   {
    return id_of_person
    (
     Record_Id(storage_of_person.freedom_keeper.get_next(id.get_record_id()))
    );
   }
 
   id_of_person previous(id_of_person id) const
   {
    return id_of_person
    (
     Record_Id(storage_of_person.freedom_keeper.get_previous(id.get_record_id()))
    );
   }
 
   template<class Comparator>
   std::vector<id_of_person> sorted_person(Comparator comparator) const;
 
   static id_of_person null_person()
   {
    return id_of_person();
   }
 
   const std::string& get_first_name(id_of_person record) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record.get_record_id()));
    return (const std::string&)(storage_of_person.field_value_of_first_name[record.get_id()]);
   }
 
   const std::string& get_last_name(id_of_person record) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record.get_record_id()));
    return (const std::string&)(storage_of_person.field_value_of_last_name[record.get_id()]);
   }
 
   id_of_city get_home(id_of_person record) const
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_person(record.get_record_id()));
    return (id_of_city)(storage_of_person.field_value_of_home[record.get_id()]);
   }
 
   const std::map<std::string, id_of_city> &get_index_of_city_by_name()
   {
    return index_of_city_by_name;
   }
 
   const std::multimap<std::tuple<std::string, std::string>, id_of_person> &get_index_of_person_by_name()
   {
    return index_of_person_by_name;
   }
 
   id_of_city next_city_by_name(id_of_city id)
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_city(id.get_record_id()));
    auto iterator = storage_of_city.iterator_over_city_by_name[id.get_id()];
    ++iterator;
    if (iterator != index_of_city_by_name.end())
     return iterator->second;
    else
     return id_of_city();
   }
   id_of_city previous_city_by_name(id_of_city id)
   {
    JOEDB_RELEASE_ASSERT(is_valid_record_id_for_city(id.get_record_id()));
    auto iterator = storage_of_city.iterator_over_city_by_name[id.get_id()];
    if (iterator != index_of_city_by_name.begin())
     return (--iterator)->second;
    else
     return id_of_city();
   }
   id_of_city find_city_by_name(const std::string& field_value_of_name) const
   {
    const auto i = index_of_city_by_name.find((field_value_of_name));
    if (i == index_of_city_by_name.end())
     return id_of_city();
    else
     return i->second;
   }
   range_of_person_by_name find_person_by_name(const std::string& field_value_of_last_name, const std::string& field_value_of_first_name) const;
 };
 /// returned by @ref Database::get_city_table
 class container_of_city
 {
  friend class Database;
 
  private:
   const Database &db;
   container_of_city(const Database &db): db(db) {}
 
  public:
   class iterator
   {
    friend class container_of_city;
    private:
     const joedb::Freedom_Keeper *fk;
     Record_Id index;
     iterator(const detail::data_of_city &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_city;
     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_city operator*() const {return id_of_city(Record_Id(index));}
   };
 
   iterator begin() const {return ++iterator(db.storage_of_city);}
   iterator end() const {return iterator(db.storage_of_city);}
   bool is_empty() const {return db.storage_of_city.freedom_keeper.get_used_count() == Record_Id{0};}
   joedb::index_t get_size() const {return to_underlying(db.storage_of_city.freedom_keeper.get_used_count());}
   static id_of_city get_at(size_t i) {return id_of_city(Record_Id(i));}
   bool is_valid_at(size_t i) {return db.storage_of_city.freedom_keeper.is_used(Record_Id(i));}
   id_of_city first() const {return *begin();}
   id_of_city last() const {return *--end();}
   id_of_city get_end() const {return *end();}
 };
 
 inline container_of_city Database::get_city_table() const
 {
  return container_of_city(*this);
 }
 
 template<class Comparator>
 std::vector<id_of_city> Database::sorted_city(Comparator comparator) const
 {
  std::vector<id_of_city> result;
  for (auto x: get_city_table())
   result.emplace_back(x);
  std::sort(result.begin(), result.end(), comparator);
  return result;
 }
 /// returned by @ref Database::get_person_table
 class container_of_person
 {
  friend class Database;
 
  private:
   const Database &db;
   container_of_person(const Database &db): db(db) {}
 
  public:
   class iterator
   {
    friend class container_of_person;
    private:
     const joedb::Freedom_Keeper *fk;
     Record_Id index;
     iterator(const detail::data_of_person &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_person;
     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_person operator*() const {return id_of_person(Record_Id(index));}
   };
 
   iterator begin() const {return ++iterator(db.storage_of_person);}
   iterator end() const {return iterator(db.storage_of_person);}
   bool is_empty() const {return db.storage_of_person.freedom_keeper.get_used_count() == Record_Id{0};}
   joedb::index_t get_size() const {return to_underlying(db.storage_of_person.freedom_keeper.get_used_count());}
   static id_of_person get_at(size_t i) {return id_of_person(Record_Id(i));}
   bool is_valid_at(size_t i) {return db.storage_of_person.freedom_keeper.is_used(Record_Id(i));}
   id_of_person first() const {return *begin();}
   id_of_person last() const {return *--end();}
   id_of_person get_end() const {return *end();}
 };
 
 inline container_of_person Database::get_person_table() const
 {
  return container_of_person(*this);
 }
 
 template<class Comparator>
 std::vector<id_of_person> Database::sorted_person(Comparator comparator) const
 {
  std::vector<id_of_person> result;
  for (auto x: get_person_table())
   result.emplace_back(x);
  std::sort(result.begin(), result.end(), comparator);
  return result;
 }
 /// returned by @ref Database::find_person_by_name
 class range_of_person_by_name
 {
  friend class Database;
  private:
   std::pair<std::multimap<std::tuple<std::string, std::string>, id_of_person>::const_iterator, std::multimap<std::tuple<std::string, std::string>, id_of_person>::const_iterator> range;
   range_of_person_by_name(const Database &db, const std::string& last_name, const std::string& first_name)
   {
    range = db.index_of_person_by_name.equal_range(std::tuple<std::string, std::string>(last_name, first_name));
   }
  public:
   class iterator
   {
    friend class range_of_person_by_name;
    private:
     std::multimap<std::tuple<std::string, std::string>, id_of_person>::const_iterator map_iterator;
     iterator(std::multimap<std::tuple<std::string, std::string>, id_of_person>::const_iterator map_iterator): map_iterator(map_iterator) {}
    public:
     bool operator !=(const iterator &i) const
     {
      return map_iterator != i.map_iterator;
     }
     iterator &operator++() {map_iterator++; return *this;}
     id_of_person operator*() const {return map_iterator->second;}
   };
   iterator begin() const {return range.first;}
   iterator end() const {return range.second;}
   bool empty() const {return range.first == range.second;}
   size_t size() const {return size_t(std::distance(range.first, range.second));}
 };
 
 inline range_of_person_by_name Database::find_person_by_name(const std::string& field_value_of_last_name, const std::string& field_value_of_first_name) const
 {
  return range_of_person_by_name(*this, field_value_of_last_name, field_value_of_first_name);
 }
}
 
#endif