Multiplexer.cpp

Go to the documentation of this file.

#include "joedb/Multiplexer.h"
 
namespace joedb
{
 ////////////////////////////////////////////////////////////////////////////
 Multiplexer::Multiplexer
 ////////////////////////////////////////////////////////////////////////////
 (
  std::initializer_list<std::reference_wrapper<Writable>> initializer_list
 ):
  writables(initializer_list),
  start_index(0)
 {
 }
 
 #define MULTIPLEX(x) do {for (size_t i = start_index; i < writables.size(); i++) writables[i].get().x;} while(0)
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::create_table(const std::string &name)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(create_table(name));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::drop_table(Table_Id table_id)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(drop_table(table_id));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::rename_table
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  const std::string &name
 )
 {
  MULTIPLEX(rename_table(table_id, name));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::add_field
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  const std::string &name,
  Type type
 )
 {
  MULTIPLEX(add_field(table_id, name, type));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::drop_field
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Field_Id field_id
 )
 {
  MULTIPLEX(drop_field(table_id, field_id));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::rename_field
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Field_Id field_id,
  const std::string &name
 )
 {
  MULTIPLEX(rename_field(table_id, field_id, name));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::custom(const std::string &name)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(custom(name));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::comment(const std::string &comment)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(comment(comment));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::timestamp(int64_t timestamp)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(timestamp(timestamp));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::valid_data()
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(valid_data());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::flush()
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(flush());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 int64_t Multiplexer::get_position() const
 ////////////////////////////////////////////////////////////////////////////
 {
  int64_t result = 0;
 
  for (auto w: writables)
  {
   result = w.get().get_position();
   if (result > 0)
    break;
  }
 
  return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::start_writing(int64_t position)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(start_writing(position));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::end_writing(int64_t position)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(end_writing(position));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::soft_checkpoint()
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(soft_checkpoint());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::hard_checkpoint()
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(hard_checkpoint());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::insert_into
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Record_Id record_id
 )
 {
  MULTIPLEX(insert_into(table_id, record_id));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::delete_from
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Record_Id record_id
 )
 {
  MULTIPLEX(delete_from(table_id, record_id));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::insert_vector
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Record_Id record_id,
  size_t size
 )
 {
  MULTIPLEX(insert_vector(table_id, record_id, size));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::delete_vector
 ////////////////////////////////////////////////////////////////////////////
 (
  Table_Id table_id,
  Record_Id record_id,
  size_t size
 )
 {
  MULTIPLEX(delete_vector(table_id, record_id, size));
 }
 
 #define TYPE_MACRO(type, return_type, type_id, R, W)\
 void Multiplexer::update_##type_id\
 (\
  Table_Id table_id,\
  Record_Id record_id,\
  Field_Id field_id,\
  return_type value\
 )\
 {\
  MULTIPLEX(update_##type_id(table_id, record_id, field_id, value));\
 }\
 void Multiplexer::update_vector_##type_id\
 (\
  Table_Id table_id,\
  Record_Id record_id,\
  Field_Id field_id,\
  size_t size,\
  const type *value\
 )\
 {\
  MULTIPLEX\
  (\
   update_vector_##type_id(table_id, record_id, field_id, size, value)\
  );\
 }\
 type *Multiplexer::get_own_##type_id##_storage\
 (\
  Table_Id table_id,\
  Record_Id record_id,\
  Field_Id field_id,\
  size_t &capacity\
 )\
 {\
  capacity = 0;\
  type *result = nullptr;\
  for (auto w: writables)\
  {\
   result = w.get().get_own_##type_id##_storage(table_id, record_id, field_id, capacity);\
   if (result)\
    break;\
  }\
  return result;\
 }
 #include "joedb/TYPE_MACRO.h"
 
 ////////////////////////////////////////////////////////////////////////////
 void Multiplexer::on_blob(Blob blob)
 ////////////////////////////////////////////////////////////////////////////
 {
  MULTIPLEX(on_blob(blob));
 }
 
 #undef MULTIPLEX
 
 ////////////////////////////////////////////////////////////////////////////
 bool Multiplexer::wants_blob_data() const
 ////////////////////////////////////////////////////////////////////////////
 {
  for (auto w: writables)
  {
   if (w.get().wants_blob_data())
    return true;
  }
 
  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 Blob Multiplexer::write_blob(const std::string &data)
 ////////////////////////////////////////////////////////////////////////////
 {
  Blob result;
 
  for (auto w: writables)
  {
   if (w.get().wants_blob_data())
    result = w.get().write_blob(data);
  }
 
  return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 Multiplexer::~Multiplexer() = default;
 ////////////////////////////////////////////////////////////////////////////
}