TextFile.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "IException.h"
#include "IException.h"
#include "FileName.h"
#include "Message.h"
#include "TextFile.h"
#include "IString.h"
 
#include <iostream>
 
#include <QFileInfo>
 
using namespace std;
namespace Isis {
 
  TextFile::TextFile() {
  }
 
  TextFile::TextFile(const QString &filename,
                     const char *openmode, const char *extension) {
    SetComment();
    SetNewLine();
    Open(filename, openmode, extension);
  }
 
  TextFile::TextFile(const QString &filename, const char *openmode,
                     std::vector<QString> &lines, const int &maxLinesToReadWrite,
                     const bool skipComments) {
    SetComment();
    SetNewLine();
    Open(filename, openmode);
    if(p_openmode == 1) {
      GetFile(lines, maxLinesToReadWrite, skipComments);
    }
    else {
      PutFile(lines, maxLinesToReadWrite);
    }
  }
  TextFile::TextFile(const char *filename, const char *openmode,
                     std::vector<QString> &lines, const int &maxLinesToReadWrite,
                     const bool skipComments) {
    TextFile(QString(filename), openmode, lines, maxLinesToReadWrite, skipComments);
  }
 
  TextFile::TextFile(const QString &filename, const char *openmode,
                     QString *lines, const int &maxLinesToReadWrite,
                     const bool skipComments) {
    SetComment();
    SetNewLine();
    Open(filename, openmode);
    if(p_openmode == 1) {
      GetFile(lines, maxLinesToReadWrite, skipComments);
    }
    else {
      PutFile(lines, maxLinesToReadWrite);
    }
  }
 
  TextFile::TextFile(const char *filename, const char *openmode,
                     QString *lines, const int &maxLinesToReadWrite,
                     const bool skipComments) {
    TextFile(QString(filename), openmode, lines, maxLinesToReadWrite, skipComments);
  }
 
 
  TextFile::~TextFile() {
    Close();
  }
 
 
  // Methods
 
  void TextFile::Open(const QString &filename, const char *openmode,
                      const char *extension) {
    // Open (filename [,openmode] [, with_extension ])
    // default openmode = 'input'
    // default extension = 'txt'; extension = "" opens without default
 
    // note: in append mode, the input and output pointers move together
 
 
    // Don't open if it already is
    if(p_stream.is_open()) {
      QString message = "TextFile:Open:-> Already opened with this object: ["
                        + QString(openmode) + "]:[" + p_filename + "]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    p_openmode = 0;
 
    // Save the filename for error messages
 
    Isis::FileName filenameTmp(filename);
    filenameTmp.addExtension(extension);
    p_filename = filenameTmp.expanded();
 
 
    //  input, output, overwrite, append
 
    string chkOpenmode = Isis::IString(openmode).DownCase();
    if(chkOpenmode == "input")      {
      p_openmode = 1;
    }
    else if(chkOpenmode == "output")     {
      p_openmode = 2;
    }
    else if(chkOpenmode == "overwrite")  {
      p_openmode = 3;
    }
    else if(chkOpenmode == "append")     {
      p_openmode = 4;
    }
    else {
      QString message = "TextFile::-> Unknown openmode: (input, output, overwrite, append):["
                       + QString(openmode) + "]:[" + p_filename + "]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    // Input
    if(p_openmode == 1) {
      p_stream.open(p_filename.toLatin1().data(), fstream::in);
    }
    // Output
    else if(p_openmode == 2) {
      // first check if file already exists
      if(filenameTmp.fileExists() && QFileInfo(filenameTmp.toString()).size() > 0) {
        QString message = "TextFile:Open: -> Output file already exists ["
                          + QString(openmode) + "]:[" + p_filename + "]";
        throw IException(IException::Io, message, _FILEINFO_);
      }
 
      p_stream.open(p_filename.toLatin1().data(), fstream::in | fstream::out | fstream::trunc);
      p_stream.clear();
    }
    // Overwrite
    else if(p_openmode == 3) {
      p_stream.open(p_filename.toLatin1().data(), fstream::in | fstream::out | fstream::trunc);
    }
    // Append
    else if(p_openmode == 4) {
      // Open in append if it does exist, otherwise, open in overwrite mode
      if(filenameTmp.fileExists()) {
        p_stream.open(p_filename.toLatin1().data(), fstream::in | fstream::out | fstream::ate);
      }
      else {
        p_stream.open(p_filename.toLatin1().data(), fstream::in | fstream::out | fstream::trunc);
      }
    }
 
    if(!p_stream.is_open()) {
      QString message = "TextFile:Open:-> Unable to open: ["
                       + QString(openmode) + "]:[" + p_filename + "]";
      throw IException(IException::Io, message, _FILEINFO_);
    }
  }
 
  bool TextFile::OpenChk(bool bailIfNotOpen) {
    if(p_stream.is_open()) {
      return(true);
    }
    else {
      if(bailIfNotOpen) {
        QString message = "TextFile::-> File not open: [" + p_filename + "]";
        throw IException(IException::Programmer, message, _FILEINFO_);
      }
      else {
        return(false);
      }
    }
  }
 
  void TextFile::Rewind() {
    OpenChk(true);
    if(p_stream.eof()) {
      p_stream.clear();
    }
    p_stream.seekg(0, ios_base::beg);
  }
 
  void TextFile::Close() {
    if(p_stream.is_open()) {
      p_stream.flush();
      p_stream.close();
    }
  }
 
  // vector array
  void TextFile::GetFile(std::vector<QString> &lines, const int &maxLinesToRead,
                         const bool skipComments) {
    OpenChk(true);
    QString line;
    int lineCount = 0;
    while(GetLine(line, skipComments)) {
      if(maxLinesToRead > 0) {
        if(lineCount++ >= maxLinesToRead) {
          break;
        };
      }
      lines.push_back(line);
    }
  }
 
  // string array
  void TextFile::GetFile(QString *lines, const int &maxLinesToRead,
                         const bool skipComments) {
    OpenChk(true);
    QString line;
    int lineCount = 0;
    while(GetLine(line, skipComments)) {
      if(maxLinesToRead > 0) {
        if(lineCount > maxLinesToRead) {
          break;
        };
      }
      else if(lines[lineCount] == "\0") {
        break;
      }
      lines[lineCount] = line;
      lineCount++;
    }
  }
 
  // vector array
  void TextFile::PutFile(std::vector<QString> &lines, const int &maxLinesToWrite) {
    OpenChk(true);
    for(int lineCount = 0; lineCount < (int) lines.size(); lineCount++) {
      if(maxLinesToWrite > 0) {
        if(lineCount > maxLinesToWrite) {
          break;
        };
      }
      PutLine(lines[lineCount]);
    }
  }
 
  // string array
  void TextFile::PutFile(const QString *lines, const int &maxLinesToWrite) {
    OpenChk(true);
    int lineCount = 0;
    while(true) {
      if(maxLinesToWrite > 0) {
        if(lineCount > maxLinesToWrite) {
          break;
        };
      }
      else if(lines[lineCount] == "\0") {
        break;
      }
      PutLine(lines[lineCount]);
      lineCount++;
    }
  }
 
  bool TextFile::GetLine(QString &line, bool skipComments) {
    return (p_GetLine(line, skipComments));
  }
 
  bool TextFile::GetLine(bool skipComments) {
    QString line;
    return (p_GetLine(line, skipComments));
  }
 
  bool TextFile::GetLineNoFilter(QString &line) {
    return (p_GetLine(line, false));
  }
 
  bool TextFile::GetLineNoFilter() {
    QString line;
    return (p_GetLine(line, false));
  }
 
  bool TextFile::p_GetLine(QString &line, bool chkComment) {
    OpenChk(true);
 
    line = "";
 
    // Try to read the next line
    std::string lineStdString;
    getline(p_stream, lineStdString);
    line = lineStdString.c_str();
 
    // Check for end of file
    if(p_stream.eof()) {
      return false;
    }
 
    // See if an error occured
    if(!p_stream.good()) {
      line = "";
      QString message = "TextFile:GetLine: -> Error reading text file: ["
                       + p_filename + "]";
      throw IException(IException::Io, message, _FILEINFO_);
    }
 
    // See if we have a comment and if we need to ignore
    if(chkComment) {
      if(p_commentString.length()) {
        int locComment = line.indexOf(p_commentString);
        if(locComment != -1) {
          int afterWhiteSpace = line.indexOf(QRegExp("[^\\s]"));
          if((locComment == 0) || (locComment == afterWhiteSpace)) {
            return p_GetLine(line, chkComment);
          }
        }
      }
    }
 
    // We have a good line
    return true;
  }
 
  void TextFile::PutLine(const QString &line) {
    PutLine(line.toLatin1().data());
  }
 
  void TextFile::PutLine(const char *line) {
    OpenChk(true);
 
    // Try to write the next line
    p_stream << line << p_newLineString;
    // See if an error occured
    if(!p_stream.good()) {
      if(p_openmode != 1) {
        QString message = "TextFile:PutLine: -> Error writing text file: ["
                         + p_filename + "]";
        throw IException(IException::Io, message, _FILEINFO_);
      }
      else {
        QString message =
          "TextFile:PutLine: -> Attempt to write to INPUT - Read Only text file: ["
          + p_filename + "]";
        throw IException(IException::Programmer, message, _FILEINFO_);
      }
    }
  }
 
  void TextFile::PutLineComment(const QString &line) {
    PutLine(p_commentString + line);
  }
 
  void TextFile::PutLineComment(const char *line) {
    PutLine(p_commentString + QString(line));
  }
 
 
  QString TextFile::GetComment() {
    return(p_commentString);
  }
 
 
  void TextFile::SetComment(const char *commentString) {
    p_commentString = commentString;
  }
 
 
  QString TextFile::GetNewLine() {
    return(p_newLineString);
  }
 
  void TextFile::SetNewLine(const char *newLineString) {
    p_newLineString = newLineString;
  }
 
  int TextFile::LineCount(const int &maxLinesToRead) {
    OpenChk(true);
 
    // LineCount ( [maxLinesToRead] )  --- returns number of lines in open file
 
    bool eofStat = false;
    if(p_stream.eof()) {  // current state of stream is 'eof'
      eofStat = true;
      p_stream.clear();
    }
 
    streampos savePos = p_stream.tellg();
    p_stream.seekg(0, ios_base::beg);
 
    int lineCount = 0;
    string tmpLine;
    if(maxLinesToRead > 0) {
      while((getline(p_stream, tmpLine)) && (lineCount <= maxLinesToRead)) {
        lineCount++;
      }
    }
    else {
      while(getline(p_stream, tmpLine)) {
        lineCount++;
      }
    }
 
    if(p_stream.eof()) {
      p_stream.clear();
    }
 
    p_stream.seekg(savePos, ios_base::beg);
 
    if(eofStat) {           // restore current state of stream 'eof'
      p_stream.seekg(0, ios_base::end);
      p_stream.get();
    }
    return lineCount;
  }
 
  streamsize TextFile::Size() {
    OpenChk(true);
 
    // Size () --- returns file size in bytes
 
    bool eofStat = false;
    if(p_stream.eof()) {  // current state of stream is 'eof'
      eofStat = true;
      p_stream.clear();
    }
 
    streampos savePos = p_stream.tellg();
    p_stream.seekg(0, ios_base::end);
    streamsize bytes = p_stream.tellg();
    p_stream.seekg(savePos, ios_base::beg);
 
    if(eofStat) {           // restore current state of stream 'eof'
      p_stream.seekg(0, ios_base::end);
      p_stream.get();
    }
    return bytes;
  }
} // end namespace isis