libs/EDoc/Persistence.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/Persistence.h"
#include "EDoc/exceptions.h"
#include "EDoc/TextPersistence.h"
#include "EDoc/BinaryPersistence.h"
#include "EDoc/stdint.h"
#include "EDoc/utils.h"
#include "EDoc/persistence_data.h"
#include "EDoc/ArchiveIFace.h"


#include <iostream>
#include <algorithm>

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

#ifdef HAVE_FCNTL_H
   #include <fcntl.h>
#endif 

#ifdef HAVE_UNISTD_H
   #include <unistd.h>
#endif 

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


//==============================================================================
// EDoc Namespace Implementation.
//==============================================================================
namespace EDoc
{
   //===========================================================================
   std::list<std::string> Persistence::temp_files;
   std::list<ArchiveIFace*> Persistence::archive_formats;
   //===========================================================================
   void Persistence::AddTempFile(std::string filename)
   {
      if (std::find(temp_files.begin(), temp_files.end(), filename) != 
         temp_files.end())
      {
         EDOC_Warning("File already in temp file list: " << filename);
         return;
      }
      
      temp_files.push_back(filename);
   }
   //===========================================================================
   void Persistence::RemoveTempFile(std::string filename)
   {
      std::list<std::string>::iterator it = std::find(temp_files.begin(),
         temp_files.end(), filename);
      if (it == temp_files.end())
      {
         EDOC_Warning("Temp file does not exist to be erased: " << filename);
         return;
      }
      temp_files.erase(it);
   }
   //===========================================================================
   void Persistence::AddArchiveFactory(ArchiveIFace* factory)
   {
      archive_formats.push_back(factory);
   }
   //===========================================================================
   std::list<ManagedFile> Persistence::ReadExtract(ManagedFile filename)
   {
      std::list<ManagedFile> files;

      // Try to open file in one of the archive formats.
      EDOC_FOREACH(ArchiveList, arch, archive_formats)
      {
         if ((*arch)->HandlesType(filename))
         {
            // List all files in archive.
            // Open each file in list
            std::list<ManagedFile> poss_files = (*arch)->ReadExtractAll(filename);
            EDOC_FOREACH(MngdFileList, pf, poss_files)
            {
               Append(files, ReadExtract(*pf));
            }

            EDOC_Fine("Pushing archives set of managed files. Count: " << files.size());
            return files;
         }
      }

      // Otherwise if we get here then we will just add the given file as a
      // source.
      EDOC_Fine("Pushing non-archive managed file: " << filename.GetName());
      files.push_back(filename);
      return files;
   }
   //===========================================================================
   std::list<Persistence> Persistence::ReadOpen(std::string filename)
   {
      std::list<Persistence> ret;
      
      // Get all possible files by extracting known archives.
      std::list<ManagedFile> poss_files(ReadExtract(ManagedFile(filename)));
      
      // For each file in list, check to see if it is a valid edoc file. If not
      // then discard it.
      EDOC_FOREACH(MngdFileList, pf, poss_files)
      {
         try
         {
            Persistence p(true, *pf, UNKNOWN);
            ret.push_back(p);
            EDOC_Fine("Got valid edoc file: " << pf->GetName());
         }
         catch(UnknownFileTypeException& e)
         {
            // If we catch this then skip that file.
            EDOC_Debug("Invalid edoc file: " << pf->GetName() 
               << ", Reason: " << e.what());
         }
      }
      
      // Return a list of all valid edc file found.
      return ret;
   }
   //===========================================================================
   Persistence Persistence::WriteOpen(std::string filename,
      EncodingType format, std::string item_name)
   {
      ManagedFile f(filename);

      // First see if the file given is a valid archive name.
      EDOC_FOREACH(ArchiveList, arch, archive_formats)
      {
         if ((*arch)->HandlesType(f))
         {
            // If it is an archive then prepare a file from it for writing.
            ManagedFile f2 = (*arch)->WriteOpen(f, item_name);
            return Persistence(false, f2, format);
         }
      }
      
      // Otherwise we will assume that the file is to be written directly as an
      // edc file.
      return Persistence(false, f, format);
   }
   //===========================================================================
   Persistence::Persistence(const Persistence& right) :
      EDoc::PersistenceIFace(),
      
      file(right.file),
      format(right.format),
      impl(right.impl)
   {
      IncRef();
   }
   //===========================================================================
   Persistence::Persistence(bool read, 
         ManagedFile file_in,
         EncodingType format_in) :
      EDoc::PersistenceIFace(),
      
      file(file_in),
      format(format_in),
      impl(NULL)
   {
      if (read)
      {
         EDOC_ASSERT(format == UNKNOWN, "");
         
         std::ifstream f(file.GetWorkFileName().c_str(), std::ios::binary);
         if (!f)
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               strerror(errno), 
               "filename: " << file.GetWorkFileName());
         }

         char temp[10];

         // Read the 1st 9 characters
         f.read(temp, 9);
         if (!f)
         {
            EDOC_THROW_EXCEPTION(UnknownFileTypeException, 
               "Failed reading file header.", 
               "filename: " << file.GetWorkFileName() 
               << ", reason: " << strerror(errno));
         }

         temp[9] = 0;
         if (!strcmp(temp, "EDoc: TXT"))
         {
            impl = new TextPersistence(read, file.GetWorkFileName());
            IncRef();
            format = TEXT;
         }
         else if (!strcmp(temp, "EDoc: BIN"))
         {
            impl = new BinaryPersistence(read, file.GetWorkFileName());
            IncRef();
            format = BINARY;
         }
         else
         {
            EDOC_THROW_EXCEPTION(UnknownFileTypeException, 
               "Unknown file format.", "");
         }
      }
      else
      {
         switch (format)
         {
            case TEXT:
            {
               impl = new TextPersistence(read, file.GetWorkFileName());
               IncRef();
               break;
            }
            case BINARY:
            {
               impl = new BinaryPersistence(read, file.GetWorkFileName());
               IncRef();
               break;
            }
            default:
            {
               EDOC_ASSERT(false, "Unknown format inputfor writing.");
            }
         }
      }
      
      EDOC_ASSERT(impl, "");
   }
   //===========================================================================
   Persistence& Persistence::operator=(const Persistence& right)
   {
      if (this == &right)
      {
         return *this;
      }
      
      DecRef();
      
      file = right.file;
      format = right.format;
      impl = right.impl;

      IncRef();
      
      return *this;
   }
   //===========================================================================
   Persistence::~Persistence()
   {
      DecRef();
   }
   //===========================================================================
   void Persistence::IncRef()
   {
      if (impl)
      {
         impl->ref_count++;
      }
   }
   //===========================================================================
   void Persistence::DecRef()
   {
      if (impl)
      {
         impl->ref_count--;
         if (impl->ref_count <= 0)
         {
            delete impl;
            impl = NULL;
         }
      }
   }
   //===========================================================================
   std::string Persistence::GetFilenameRep() const
   {
      return file.GetFileNameRep();
   }
   //===========================================================================
}

---