AbstractFile.C

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 | Library QgarLib, graphics analysis and recognition                  |
 | Copyright (C) 2002  Qgar Project, LORIA                             |
 |                                                                     |
 | This library is free software; you can redistribute it and/or       |
 | modify it under the terms of the GNU Lesser General Public          |
 | License version 2.1, as published by the Free Software Foundation.  |
 |                                                                     |
 | 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.                |
 | See the GNU Lesser General Public License for more details.         |
 |                                                                     |
 | The GNU Lesser General Public License is included in the file       |
 | LICENSE.LGPL, in the root directory of the Qgar packaging. See      |
 | http://www.gnu.org/licenses/lgpl.html for the terms of the licence. |
 | To receive a paper copy, write to the Free Software Foundation,     |
 | Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.       |
 |                                                                     |
 | Contact Project Qgar for any information:                           |
 |   LORIA - équipe Qgar                                               |
 |   B.P. 239, 54506 Vandoeuvre-lès-Nancy Cedex, France                |
 |   email: qgar-contact@loria.fr                                      |
 |   http://www.qgar.org/                                              |
 *---------------------------------------------------------------------*/


/**
 * @file   AbstractFile.C
 * @brief  Implementation of class qgar::AbstractFile.
 *
 *         See file AbstractFile.H for the interface.
 *
 * @author <a href="mailto:qgar-develop@loria.fr?subject=Qgar fwd Gérald Masini">Gérald Masini</a>
 * @date   July 2, 2001  17:13
 * @since  Qgar 1.0
 */


// STL
#include <fstream>
#include <string>
#include <sstream>
// QGAR
#include <qgarlib/AbstractFile.H>
#include <qgarlib/QgarErrorIO.H>
#include <qgarlib/QgarErrorInvalidArg.H>
#include <qgarlib/QgarErrorUser.H>


namespace qgar
{


// ---------------------------------------------------------------------
// C O N S T R U C T O R S
// ---------------------------------------------------------------------


AbstractFile::AbstractFile(const char* aFileName)

  throw(QgarErrorInvalidArg)

  : _fileStatus(QGE_FILE_STATUS_CLOSED)

{
  _fileStream.close();

  if (aFileName == 0)
    {
      throw QgarErrorInvalidArg(__FILE__, __LINE__,
                                "qgar::AbstractFile::AbstractFile(const char*)",
                                "File name not instantiated");
    }

  if (*aFileName == '\0')
    {
      throw QgarErrorInvalidArg(__FILE__, __LINE__,
                                "qgar::AbstractFile::AbstractFile(const char*)",
                                "Empty file name");
    }

  _fileName = new char[strlen(aFileName) + 1];
  strcpy(_fileName, aFileName);
}


// -------------------------------------------------------------------
// D E S T R U C T O R 
// -------------------------------------------------------------------


AbstractFile::~AbstractFile()
{
  delete [] _fileName;
}


// ---------------------------------------------------------------------
// O P E N I N G    A N D    C L O S I N G
// ---------------------------------------------------------------------


// OPEN IN READ-ONLY MODE

void
AbstractFile::openRONLY()

  throw(QgarErrorIO)

{
  close();

  _fileStream.clear();
  _fileStream.open(_fileName, std::ios::in | std::ios::binary);

  if (!_fileStream)
    {
      std::ostringstream os;
      os << "Cannot open input file: "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::AbstractFile::openRONLY()",
                        os.str());
    }

  _fileStatus = QGE_FILE_STATUS_READ_ONLY;
  _fileStream.seekg(0);
  readHeader();
}


// OPEN FOR WRITE-ONLY MODE

void
AbstractFile::openWONLY()

  throw(QgarErrorIO)

{
  close();
  // Courtesies of Microsoft Corp.:
  // 1. the failbits MUST be cleared before calling open()
  // 2. ios::trunc MUST be specified within MSVC++
  _fileStream.clear();
  _fileStream.open(_fileName, std::ios::out | std::ios::trunc | std::ios::binary);

  if (!_fileStream)
    {
      std::ostringstream os;
      os << "Cannot open output file: "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::AbstractFile::openWONLY()",
                        os.str());
    }

  _fileStatus = QGE_FILE_STATUS_WRITE_ONLY;
  writeHeader();
}


// OPEN IN APPEND MODE

void
AbstractFile::openAPPEND()

  throw(QgarErrorIO)

{
  close();
  // Courtesy of Microsoft Corp.:
  // the failbits MUST be cleared before calling open()
  _fileStream.clear();

  _fileStream.open(_fileName, std::ios::app | std::ios::binary);
  if (!_fileStream)
    {
      std::ostringstream os;
      os << "Cannot open append file: "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::AbstractFile::openAPPEND()",
                        os.str());
    }

  _fileStatus = QGE_FILE_STATUS_APPEND;
  _fileStream.seekg(0);
  readHeader();
  _fileStream.seekg(0, std::ios::end);
}


// OPEN IN READ-WRITE MODE

void
AbstractFile::openRW()

  throw(QgarErrorIO)

{
  close();
  _fileStream.open(_fileName, std::ios::in | std::ios::out | std::ios::binary);
  if (!_fileStream) 
    {
      std::ostringstream os;
      os << "Cannot open read/write file: "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::AbstractFile::openRW()",
                        os.str());
    }

  _fileStatus = QGE_FILE_STATUS_READ_WRITE;
  _fileStream.seekg(0);
  writeHeader();
}


// OPEN IN READ-APPEND MODE

void
AbstractFile::openRA()

  throw(QgarErrorIO)

{
  close();
  _fileStream.open(_fileName, std::ios::in | std::ios::app | std::ios::binary);

  if (!_fileStream)
    {
      std::ostringstream os;
      os << "Cannot open read/append file: "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::AbstractFile::openRA()",
                        os.str());
    }

  _fileStatus = QGE_FILE_STATUS_READ_APPEND;
  _fileStream.seekg(0);
  readHeader();
  _fileStream.seekg(0, std::ios::end);
}


// CLOSE FILE

void
AbstractFile::close()
{
  if (_fileStatus != QGE_FILE_STATUS_CLOSED)
 {
   if (   (_fileStatus == QGE_FILE_STATUS_WRITE_ONLY)
       || (_fileStatus == QGE_FILE_STATUS_READ_WRITE))
     {
       writeFooter();
     }

   _fileStream.close();
   _fileStatus = QGE_FILE_STATUS_CLOSED;
  }
}


// ---------------------------------------------------------------------
// T E S T I N G    S T A T U S
// ----------------------------------------------------------------------


void
AbstractFile::isOpenR()

  throw(QgarErrorUser)

{
  if (   (_fileStatus == QGE_FILE_STATUS_WRITE_ONLY)
      || (_fileStatus == QGE_FILE_STATUS_APPEND))
    {
      std::ostringstream os;
      os << "File not open in read mode: "
         << _fileName;
      throw QgarErrorUser(__FILE__, __LINE__,
                          "void qgar::AbstractFile::isOpenR()",
                          os.str());
    }
}


void
AbstractFile::isOpenW()

  throw(QgarErrorUser)

{
  if (_fileStatus == QGE_FILE_STATUS_READ_ONLY)
    {
      std::ostringstream os;
      os << "File not open in write mode: "
         << _fileName;
      throw QgarErrorUser(__FILE__, __LINE__,
                          "void qgar::AbstractFile::isOpenW()",
                          os.str());
    }
}


void
AbstractFile::isOpenA()

  throw(QgarErrorUser)

{
  if (   (_fileStatus != QGE_FILE_STATUS_APPEND)
      && (_fileStatus != QGE_FILE_STATUS_READ_APPEND))
    {
      std::ostringstream os;
      os << "File not open in append mode: "
         << _fileName;
      throw QgarErrorUser(__FILE__, __LINE__,
                          "void qgar::AbstractFile::isOpenA()",
                          os.str());
    }
}


void
AbstractFile::isOpenRW()

  throw(QgarErrorUser)

{
  if (_fileStatus != QGE_FILE_STATUS_READ_WRITE)
    {
      std::ostringstream os;
      os << "File not open in read/write mode: "
         << _fileName;
      throw QgarErrorUser(__FILE__, __LINE__,
                          "void qgar::AbstractFile::isOpenRW()",
                          os.str());
    }
}


void
AbstractFile::isOpenRA()

  throw(QgarErrorUser)

{
  if (_fileStatus != QGE_FILE_STATUS_READ_APPEND)
    {
      std::ostringstream os;
      os << "File not open in read/append mode: "
         << _fileName;
      throw QgarErrorUser(__FILE__, __LINE__,
                          "void qgar::AbstractFile::isOpenRA()",
                          os.str());
    }
}

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

} // namespace qgar