Encoded_File.cpp

Go to the documentation of this file.

#include "joedb/journal/Encoded_File.h"
 
namespace joedb
{
 //////////////////////////////////////////////////////////////////////////
 void Encoded_File::sync()
 //////////////////////////////////////////////////////////////////////////
 {
  flush_write_buffer();
  db.hard_checkpoint();
 }
 
 //////////////////////////////////////////////////////////////////////////
 size_t Encoded_File::pread
 //////////////////////////////////////////////////////////////////////////
 (
  char * const buffer,
  const size_t size,
  const int64_t offset
 ) const
 {
  flush_write_buffer();
  return Readonly_Encoded_File::pread(buffer, size, offset);
 }
 
 //////////////////////////////////////////////////////////////////////////
 void Encoded_File::write_blob(const std::string_view buffer, int64_t offset) const
 //////////////////////////////////////////////////////////////////////////
 {
  const Blob blob = db.write_blob(codec.encode(buffer));
  db.new_buffer(blob, int64_t(buffer.size()), offset);
  db.soft_checkpoint();
 }
 
 //////////////////////////////////////////////////////////////////////////
 void Encoded_File::flush_write_buffer() const
 //////////////////////////////////////////////////////////////////////////
 {
  if (write_buffer_size > 0)
  {
   write_blob(std::string_view(write_buffer.data(), write_buffer_size), write_buffer_offset);
   write_buffer_size = 0;
  }
 }
 
 //////////////////////////////////////////////////////////////////////////
 void Encoded_File::pwrite(const char *buffer, size_t size, int64_t offset)
 //////////////////////////////////////////////////////////////////////////
 {
  if (write_buffer_size)
  {
   if (write_buffer_offset + int64_t(write_buffer_size) != offset)
    flush_write_buffer();
   else
   {
    const size_t room = write_buffer_capacity - write_buffer_size;
    const size_t s = std::min(room, size);
    std::memcpy(write_buffer.data() + write_buffer_size, buffer, s);
    write_buffer_size += s;
    buffer += s;
    offset += int64_t(s);
    size -= s;
   }
  }
 
  if (size > 0)
  {
   flush_write_buffer();
   while (size >= write_buffer_capacity)
   {
    write_blob(std::string_view(buffer, write_buffer_capacity), offset);
    buffer += write_buffer_capacity;
    offset += write_buffer_capacity;
    size -= write_buffer_capacity;
   }
  }
 
  if (size > 0)
  {
   std::memcpy(write_buffer.data(), buffer, size);
   write_buffer_offset = offset;
   write_buffer_size = size;
  }
 }
 
 //////////////////////////////////////////////////////////////////////////
 Encoded_File::Encoded_File
 //////////////////////////////////////////////////////////////////////////
 (
  Codec &codec,
  db::encoded_file::Writable_Database &db
 ):
  Readonly_Encoded_File
  (
   codec,
   db,
   db.get_journal().get_file(),
   Open_Mode::write_existing_or_create_new
  ),
  db(db),
  codec(codec),
  write_buffer(write_buffer_capacity),
  write_buffer_offset(0),
  write_buffer_size(0)
 {
 }
 
 //////////////////////////////////////////////////////////////////////////
 int64_t Encoded_File::get_size() const
 //////////////////////////////////////////////////////////////////////////
 {
  return std::max
  (
   write_buffer_offset + int64_t(write_buffer_size),
   Readonly_Encoded_File::get_size()
  );
 }
 
 //////////////////////////////////////////////////////////////////////////
 Encoded_File::~Encoded_File()
 //////////////////////////////////////////////////////////////////////////
 {
  try
  {
   flush_write_buffer();
  }
  catch (...)
  {
  }
 }
}