Abstract_File.cpp

Go to the documentation of this file.

#include "joedb/journal/Abstract_File.h"
#include "joedb/journal/Async_Reader.h"
#include "joedb/error/Exception.h"
 
#include <array>
#include <cstring>
 
namespace joedb
{
 using Default_Buffer = std::array<char, 1 << 12>;
 
 ////////////////////////////////////////////////////////////////////////////
 void Abstract_File::full_pread
 ////////////////////////////////////////////////////////////////////////////
 (
  char *data,
  const size_t size,
  const int64_t offset
 ) const
 {
  size_t result = 0;
 
  while (result < size)
  {
   const size_t read_count = pread
   (
    data + result,
    size - result,
    offset + int64_t(result)
   );
 
   if (read_count == 0)
    reading_past_end_of_file();
 
   result += read_count;
  }
 }
 
 ////////////////////////////////////////////////////////////////////////////
 void Abstract_File::copy_to
 ////////////////////////////////////////////////////////////////////////////
 (
  Abstract_File &destination,
  const int64_t start,
  const int64_t size
 ) const
 {
  Default_Buffer buffer;
 
  int64_t done = 0;
 
  while (size < 0 || done < size)
  {
   const size_t asked = size < 0
    ? buffer.size()
    : size_t(std::min(int64_t(buffer.size()), size - done));
   const size_t received = pread(buffer.data(), asked, start + done);
 
   if (received == 0)
   {
    if (size < 0)
     return;
    else
     reading_past_end_of_file();
   }
 
   destination.pwrite(buffer.data(), received, start + done);
   done += int64_t(received);
  }
 }
 
 ////////////////////////////////////////////////////////////////////////////
 bool Abstract_File::equal_to
 ////////////////////////////////////////////////////////////////////////////
 (
  const Abstract_File &destination,
  const int64_t from,
  const int64_t until
 ) const
 {
  Default_Buffer buffer;
  Default_Buffer destination_buffer;
 
  for (int64_t current = from; current < until;)
  {
   const size_t n0 = pread
   (
    buffer.data(),
    size_t(std::min(int64_t(buffer.size()), until - current)),
    current
   );
 
   size_t n1 = 0;
 
   while (n1 < n0)
   {
    const size_t n = destination.pread
    (
     destination_buffer.data() + n1,
     n0 - n1,
     current + int64_t(n1)
    );
 
    if (n == 0)
     break;
 
    n1 += n;
   }
 
   if (n1 != n0)
    return false;
 
   if (n0 == 0)
    reading_past_end_of_file();
 
   const int diff = std::memcmp
   (
    buffer.data(),
    destination_buffer.data(),
    n0
   );
 
   if (diff)
    return false;
 
   current += int64_t(n0);
  }
 
  return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
 void Abstract_File::reading_past_end_of_file()
 //////////////////////////////////////////////////////////////////////////
 {
  throw Exception("Trying to read past the end of file");
 }
 
 ////////////////////////////////////////////////////////////////////////////
 std::string Abstract_File::read_blob(Blob blob, int64_t max_size) const
 ////////////////////////////////////////////////////////////////////////////
 {
  if
  (
   blob.get_position() < 0 ||
   blob.get_size() < 0 ||
   (max_size >= 0 && blob.get_size() > max_size)
  )
  {
   reading_past_end_of_file();
  }
 
  Async_Reader reader(*this, blob.get_position(), blob.get_end());
  std::string result(size_t(blob.get_size()), 0);
  reader.read(result.data(), result.size());
  if (reader.is_end_of_file())
   reading_past_end_of_file();
  return result;
 }
}