include/EDoc/BinaryPersistence.h

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

*******************************************************************************/
#ifndef EDOC_BINARYPERSISTENCE_H
#define EDOC_BINARYPERSISTENCE_H

#include "EDoc/stdint.h"
#include "EDoc/PersistenceIFace.h"

#include <string>
#include <fstream>

namespace EDoc
{
   //===========================================================================
   /** \brief An implementation of PersistenceIFace for writing to binary files.
    *
    * This implementation of PersistenceIFace is much more efficient than its
    * text counterpart in both size of the data file and speed of
    * reading/writing. However it does not lend itself easily to debugging
    * problems.
    */
   class BinaryPersistence : public PersistenceIFace
   {
   public:

      //------------------------------------------------------------------------
      /** \brief Create an instance that represents a binary file for reading 
       * OR writing (But not both at once).
       *
       * Note: This does not open the file for reading/writing but just creates 
       * an instance of this class that is prepared for reading/writing to the
       * file.
       *
       * \param read If true then the file is considered an input file and can
       * only be used for reading. Otherwise it will be considered an output
       * file and will only be available for writing to.
       *
       * \param filename The name of the file to open.
       */
      BinaryPersistence(bool read, std::string filename);

      //------------------------------------------------------------------------
      /** \brief Closes the file upon destruction.
       */
      virtual ~BinaryPersistence();

      //------------------------------------------------------------------------
      /** \brief Opens the file
       */
      virtual void Open();

      //------------------------------------------------------------------------
      /** \brief Closes the file.
       */
      virtual void Close();

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual std::string ReadString(const char* key);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual bool ReadBoolean(const char* key);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual uint8_t ReadUInt8(const char* key);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual int32_t ReadInt32(const char* key);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual uint32_t ReadUInt32(const char* key);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual uint8_t ReadRecordType();


      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteString(const char* key, std::string value);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteBoolean(const char* key, bool value);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteUInt8(const char* key, uint8_t value);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteInt32(const char* key, int32_t value);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteUInt32(const char* key, uint32_t value);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteUInt32Debug(const char* key, uint32_t value, 
         std::string debug_text);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteInt32Debug(const char* key, int32_t value, 
         std::string debug_text);

      //------------------------------------------------------------------------
      /** \brief See PersistenceIFace
       */
      virtual void WriteRecordType(uint8_t value);

      //------------------------------------------------------------------------

   private:

      //------------------------------------------------------------------------
      /** \brief Used internally to read some data into a buffer.
       */
      void ReadData(char* buffer, size_t amount, const char* key);

      //------------------------------------------------------------------------
      /** \brief The file stream object that will be manipulated.
       */
      std::fstream file;

      //------------------------------------------------------------------------
      /** \brief True if reading from the file or false if writing to it.
       */
      bool reading;

      //------------------------------------------------------------------------
      /** \brief The name of the file being operated on.
       */
      std::string filename;

      //------------------------------------------------------------------------

   };
   //===========================================================================

}


#endif // EDOC_BINARYPERSISTENCE_H

---