libs/EDoc/BinaryPersistence.cpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library is distributed in the hope that it will be useful, 
   but WITHOUT ANY WARRANTY; without even the implied warranty of 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/
#include "config.h"

#include "EDoc/BinaryPersistence.h"
#include "EDoc/persistence_data.h"
#include "EDoc/exceptions.h"
#include "EDoc/utils.h"

#include <iostream>

#ifdef HAVE_STRING_H
   #include <string.h>
#endif

#ifdef HAVE_ERRNO_H
   #include <errno.h>
#endif

//#define EDOC_LOG_LEVEL EDOC_LOG_LEVEL_FINE
//#include "EDoc/Logger.h"

namespace EDoc
{
   //===========================================================================
   BinaryPersistence::BinaryPersistence(bool reading_in, 
         std::string filename_in) :

      reading(reading_in),
      filename(filename_in)
   {
   }
   //===========================================================================
   BinaryPersistence::~BinaryPersistence()
   {
      Close();
   }
   //===========================================================================
   void BinaryPersistence::Open()
   {
      if (reading)
      {
         EDOC_Debug("Opening file: " << filename << " for reading.");
         file.open(filename.c_str(), std::ios::in | std::ios::binary);

         char temp[10];
         // Read the 1st 9 characters
         file.read(temp, 9);
         if (!file)
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "Failed reading file header.", 
               "filename: " << filename 
               << ", reason: " << strerror(errno));
         }

         temp[9] = 0;
         EDOC_Debug("File header contains: " << temp);
         if (strcmp(temp, "EDoc: BIN"))
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "File header was not valid.",
               "read: " << temp << ", expected: " << "EDoc: TXT");
         }
      }
      else
      {
         file.open(filename.c_str(), std::ios::out | std::ios::binary);
         file << "EDoc: BIN" << std::flush;
      }
   }
   //===========================================================================
   void BinaryPersistence::Close()
   {
      file.close();
   }
   //===========================================================================
   void BinaryPersistence::ReadData(char* buffer, size_t amount, 
      const char* key)
   {
      EDOC_Finest("Reading " << amount << " bytes of data for key: " << key);
      file.read(buffer, amount);
      if (file.eof())
      {
         EDOC_THROW_EXCEPTION(EOFException, 
            "End Of File encountered.",
            "key: " << key);
      }
      else if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed reading key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
   }
   //===========================================================================
   std::string BinaryPersistence::ReadString(const char* key)
   {
      EDOC_Finer("Read string: " << key);
      if (!reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Reading from a write only persistence layer.",
            "key: " << key);
      }

      uint32_t size = ReadUInt32("size");
      char* buffer = new char[size];
      try
      {
         ReadData(buffer, size, key);
      }
      catch(...)
      {
         delete [] buffer;
         throw;
      }
      std::string ret(buffer, size);
      delete [] buffer;
      EDOC_Fine("Read string: " << key << ", value: " << ret);
      return ret;
   }
   //===========================================================================
   bool BinaryPersistence::ReadBoolean(const char* key)
   {
      EDOC_Finer("Read boolean: " << key);
      if (!reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Reading from a write only persistence layer.",
            "key: " << key);
      }
      
      uint8_t data = 0;
      file.read((char*)&data, 1);
      if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed reading key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
      
      if (data == 0x00)
      {
         EDOC_Fine("Read boolean: " << key << ", value: " << "FALSE");
         return false;
      }
      else if (data == 0xFF)
      {
         EDOC_Fine("Read boolean: " << key << ", value: " << "TRUE");
         return true;
      }
      else
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Invalid data for a boolean type.", 
            "filename: " << filename 
            << ", data: " << (unsigned int)data);
      }
   }
   //===========================================================================
   uint8_t BinaryPersistence::ReadUInt8(const char* key)
   {
      EDOC_Finer("Read uint8: " << key);
      if (!reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Reading from a write only persistence layer.",
            "key: " << key);
      }

      uint8_t data = 0;
      ReadData((char*)&data, 1, key);
      EDOC_Fine("Read uint8: " << key << ", value: " << (unsigned int)data);
      return data;
   }
   //===========================================================================
   int32_t BinaryPersistence::ReadInt32(const char* key)
   {
      EDOC_Finer("Read int32: " << key);
      return ReadUInt32(key);
   }
   //===========================================================================
   uint32_t BinaryPersistence::ReadUInt32(const char* key)
   {
      EDOC_Finer("Read uint32: " << key);
      if (!reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Reading from a write only persistence layer.",
            "key: " << key);
      }

      uint32_t data = 0;
      uint8_t temp[4];
      ReadData((char*)&temp, 4, key);
      data = (temp[3]) |
             (temp[2] << 8) |
             (temp[1] << 16) |
             (temp[0] << 24);
      EDOC_Fine("Read uint32: " << key << ", value: " << data);
      return data;
   }
   //===========================================================================
   uint8_t BinaryPersistence::ReadRecordType()
   {
      EDOC_Finer("Read record type: " << KEY_RECORD_TYPE);
      return ReadUInt8(KEY_RECORD_TYPE);
   }
   //===========================================================================
   void BinaryPersistence::WriteString(const char* key, std::string value)
   {
      EDOC_Fine("Write string: " << key << ", value: " << value);
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value);
      }

      uint32_t size = value.size();
      WriteUInt32("size", size);
      file.write(value.c_str(), size);
      if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed writing key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
   }
   //===========================================================================
   void BinaryPersistence::WriteBoolean(const char* key, bool value)
   {
      EDOC_Fine("Write boolean: " << key << ", value: " << value);
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value);
      }

      uint8_t data = 0;
      if (value)
      {
         data = 0xFF;
      }
      
      file.write((char*)&data, 1);
      if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed writing key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
   }
   //===========================================================================
   void BinaryPersistence::WriteUInt8(const char* key, uint8_t value)
   {
      EDOC_Fine("Write uint8: " << key << ", value: " << value);
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value);
      }

      file.write((char*)&value, 1);
      if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed writing key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
   }
   //===========================================================================
   void BinaryPersistence::WriteInt32(const char* key, int32_t value)
   {
      EDOC_Fine("Write int32: " << key << ", value: " << value);
      WriteUInt32(key, value);
   }
   //===========================================================================
   void BinaryPersistence::WriteUInt32(const char* key, uint32_t value)
   {
      EDOC_Fine("Write uint32: " << key << ", value: " << value);
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value);
      }


      uint8_t temp[4];
      temp[3] = value & 0x000000FF;
      temp[2] = (value & 0x0000FF00) >> 8;
      temp[1] = (value & 0x00FF0000) >> 16;
      temp[0] = (value & 0xFF000000) >> 24;
      
      file.write((char*)temp, 4);
      if (!file)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Failed writing key: " << key, 
            "filename: " << filename 
            << ", reason: " << strerror(errno));
      }
   }
   //===========================================================================
   void BinaryPersistence::WriteUInt32Debug(const char* key, uint32_t value, 
      std::string EDOC_UNUSED(debug_text))
   {
      WriteUInt32(key, value);
   }
   //===========================================================================
   void BinaryPersistence::WriteInt32Debug(const char* key, int32_t value, 
      std::string EDOC_UNUSED(debug_text))
   {
      WriteInt32(key, value);
   }
   //===========================================================================
   void BinaryPersistence::WriteRecordType(uint8_t value)
   {
      EDOC_Fine("Write record type: " << KEY_RECORD_TYPE << ", value: " 
         << (unsigned int) value);
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << KEY_RECORD_TYPE << ", value: " << value);
      }

      WriteUInt8(KEY_RECORD_TYPE, value);
   }
   //===========================================================================
}

---