libs/EDoc/TextPersistence.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/TextPersistence.h"
#include "EDoc/persistence_data.h"
#include "EDoc/exceptions.h"

#include <iostream>

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

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

namespace EDoc
{
   //===========================================================================
   TextPersistence::TextPersistence(bool reading_in, std::string filename_in) :
      reading(reading_in),
      line_count(0),
      filename(filename_in)
   {
   }
   //===========================================================================
   TextPersistence::~TextPersistence()
   {
      Close();
   }
   //===========================================================================
   void TextPersistence::Open()
   {
      if (reading)
      {
         file.open(filename.c_str(), std::ios::in);

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

         temp[9] = 0;
         if (strcmp(temp, "EDoc: TXT"))
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "File header was not valid.",
               "read: " << temp << ", expected: " << "EDoc: TXT" 
               << ", line: " << line_count);
         }

         // Reset the file pointer.
         file.seekg(0);

         // Read the first line and discard.
         GetNextLine();
      }
      else
      {
         file.open(filename.c_str(), std::ios::out);
         file << "EDoc: TXT" << std::endl;
         file << std::endl;
      }
   }
   //===========================================================================
   void TextPersistence::Close()
   {
      file.close();
   }
   //===========================================================================
   bool TextPersistence::ContainsData(const std::string& data)
   {
      size_t len = data.size();
      for (size_t i = 0; i < len; i++)
      {
         if (!std::isspace(data[i]))
         {
            return true;
         }
      }

      return false;
   }
   //===========================================================================
   std::string TextPersistence::GetNextLine(const char* key_in, 
      const char* type_in)
   {
      if (!reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Reading from a write only persistence layer.",
            "key: " << key_in << ", type: " << type_in
             << ", line: " << line_count);
      }

      std::string temp = "";
      while (!ContainsData(temp))
      {
         if (!file)
         {
            EDOC_THROW_EXCEPTION(EOFException, 
               "End Of File encountered.",
               "key: " << key_in << ", type: " << type_in
                << ", line: " << line_count);
         }
         std::getline(file, temp);
         line_count++;
      }

      EDOC_Finer("Read line: " << temp);
      return temp;
   }
   //===========================================================================
   std::string TextPersistence::ReadValue(const char* key_in, 
      const char* type_in)
   {
      // Get the next line from the file.
      std::string line;

      size_t start_key = 0;
      size_t end_key = 0;

      size_t start_value = 0;

      // Get the first non comment line.
      do
      {
         line = GetNextLine();

         for(start_key = 0; start_key < line.size(); start_key++)
         {
            if (!std::isspace(line[start_key]))
            {
               break;
            }
         }
         if (start_key == line.size())
         {
            EDOC_THROW_EXCEPTION(BugException, 
               "GetLine() returned a string with only spaces in it.",

               "\n\nInput Key: " << key_in 
               << "\nInput Type: " << type_in 
               << "\nCurrent input line: line: " << line_count
               << "\nLine contents: " << line);
         }
      }
      while (line[start_key] == BJC_PERSIST_COMMENT_CHAR);

      // Should start with start char.
      if (line[start_key] != BJC_PERSIST_START_KEY_CHAR)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Key should start with $.",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      // Find the end of key character.
      end_key = line.find(BJC_PERSIST_FINISH_KEY_CHAR, start_key + 1);
      if (end_key == std::string::npos)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Key should end with : char,",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      if (line.size() <= end_key + 1)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Line contains no value field.",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      if (line[end_key + 1] != ' ')
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "A space should always seperate key/value. I.e. Always place a "
            "space after the : char.",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      start_value = end_key + 2;
      std::string value = line.substr(start_value);

      if ((start_key + 2) >= end_key)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Not enough data.",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      std::string key = line.substr(start_key + 1, (end_key - start_key - 1));
      if (!key.size())
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Empty key.",

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      // Now to remove the type information from the key if therre is any.
      if (key[key.size() -1] == ')')
      {
         size_t start_type = key.rfind('(');
         if (start_type == std::string::npos)
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "Key contains a ) char. No matching ( for providing a type.",

               "\n\nInput Key: " << key_in 
               << "\nInput Type: " << type_in 
               << "\nCurrent input line: line: " << line_count
               << "\nLine contents: " << line);
         }

         std::string type = key.substr(start_type + 1, key.size() - 
            start_type - 2);
         key = key.substr(0, start_type);

         if (type != type_in)
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "Mismatching types."
                  << "\nExpected type: " << type_in 
                  << "\nReceived type: " << type,

               "\n\nInput Key: " << key_in 
               << "\nInput Type: " << type_in 
               << "\nCurrent input line: line: " << line_count
               << "\nLine contents: " << line);
         }
      }

      //std::cerr << "key: " << key << std::endl;
      //std::cerr << "value: " << value << std::endl;
      if (key != key_in)
      {
         EDOC_THROW_EXCEPTION(FileIOException, 
            "Mismatching keys."
               << "\nExpected key: " << key_in 
               << "\nReceived key: " << key,

            "\n\nInput Key: " << key_in 
            << "\nInput Type: " << type_in 
            << "\nCurrent input line: line: " << line_count
            << "\nLine contents: " << line);
      }

      return value;
   }
   //===========================================================================
   std::string TextPersistence::ReadString(const char* key)
   {
      return ReadValue(key, "string");
   }
   //===========================================================================
   bool TextPersistence::ReadBoolean(const char* key)
   {
      std::string value = ReadValue(key, "bool");

      if (value == "true")
      {
         return true;
      }
      else if (value == "false")
      {
         return false;
      }

      EDOC_THROW_EXCEPTION(FileIOException, "Invalid boolean value.",
         "key: " << key << ", value: " << value
          << ", line: " << line_count);
   }
   //===========================================================================
   uint8_t TextPersistence::ReadUInt8(const char* key)
   {
      std::istringstream stream(ReadValue(key, "uint8"));
      uint value = 0;
      stream >> value;
      if (!stream)
      {
         EDOC_THROW_EXCEPTION(FileIOException, "Invalid uint8 value.",
            "key: " << key << ", value: " << stream.str()
             << ", line: " << line_count);
      }

      if ((value & 0xFF) != value)
      {
         EDOC_THROW_EXCEPTION(FileIOException, "Value to large for uint8.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      return value;
   }
   //===========================================================================
   int32_t TextPersistence::ReadInt32(const char* key)
   {
      std::istringstream stream(ReadValue(key, "int32"));
      int32_t value = 0;
      stream >> value;
      if (!stream)
      {
         EDOC_THROW_EXCEPTION(FileIOException, "Invalid int32 value.",
            "key: " << key << ", value: " << stream.str()
             << ", line: " << line_count);
      }

      return value;
   }
   //===========================================================================
   uint32_t TextPersistence::ReadUInt32(const char* key)
   {
      // Note: This ignores any additional "debug" data on the rest of the line
      // and just reads the first int.
      std::istringstream stream(ReadValue(key, "uint32"));
      uint32_t value = 0;
      stream >> value;
      if (!stream)
      {
         EDOC_THROW_EXCEPTION(FileIOException, "Invalid uint32 value.",
            "key: " << key << ", value: " << stream.str()
             << ", line: " << line_count);
      }

      return value;
   }
   //===========================================================================
   uint8_t TextPersistence::ReadRecordType()
   {
      return ReadUInt8(KEY_RECORD_TYPE);
   }
   //===========================================================================
   void TextPersistence::WriteString(const char* key, std::string value)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(string)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteBoolean(const char* key, bool value_in)
   {
      std::string value = "false";
      if (value_in)
      {
         value = "true";
      }

      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(bool)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteUInt8(const char* key, uint8_t value)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << (uint32_t)value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(uint8)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << (uint32_t)value << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteInt32(const char* key, int32_t value)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(int32)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteUInt32(const char* key, uint32_t value)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(uint32)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteUInt32Debug(const char* key, uint32_t value, 
      std::string debug_text)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(uint32)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << " " << debug_text << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteInt32Debug(const char* key, int32_t value, 
      std::string debug_text)
   {
      if (reading)
      {
         EDOC_THROW_EXCEPTION(BugException, 
            "Writing to a read only persistence layer.",
            "key: " << key << ", value: " << value
             << ", line: " << line_count);
      }

      file << BJC_PERSIST_START_KEY_CHAR 
         << key << "(int32)"
         << BJC_PERSIST_FINISH_KEY_CHAR
         << " " << value << " " << debug_text << std::endl;
      line_count++;
   }
   //===========================================================================
   void TextPersistence::WriteRecordType(uint8_t value)
   {
      file << std::endl;
      WriteUInt8(KEY_RECORD_TYPE, value);
   }
   //===========================================================================
}

---