IException.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "IException.h"
 
#include <stdlib.h>
 
#include <algorithm>
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
 
#include <QList>
 
#include "Application.h"
#include "Preference.h"
#include "Pvl.h"
 
using namespace std;
 
namespace Isis {
  IException::IException() {
    m_what = NULL;
    m_errorType = Unknown;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
    m_lineNumber = -1;
 
    m_what = buildWhat();
  }
 
 
  IException::IException(ErrorType type, const QString &message,
                         const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(QString(message).trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    m_what = buildWhat();
  }
 
 
  IException::IException(ErrorType type, const char *message,
                         const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(QString(message).trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    m_what = buildWhat();
  }
 
 
  IException::IException(ErrorType type, const std::string &message,
                         const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(QString(message.c_str()).trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    m_what = buildWhat();
  }
 
 
  IException::IException(const IException &caughtException,
      ErrorType type, const char *message,
      const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(QString(message).trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    append(caughtException);
  }
 
 
  IException::IException(const IException &caughtException,
      ErrorType type, const std::string &message,
      const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(QString(message.c_str()).trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    append(caughtException);
  }
 
 
  IException::IException(const IException &caughtException,
      ErrorType type, const QString &message,
      const char *fileName, int lineNumber) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = type;
    m_message = new QString(message.trimmed());
    m_fileName = new QString(fileName);
    m_lineNumber = lineNumber;
 
    deleteEmptyMemberStrings();
 
    append(caughtException);
  }
 
 
  IException::IException(const IException &other) : exception(other) {
    m_what = NULL;
    m_message = NULL;
    m_fileName = NULL;
    m_previousExceptions = NULL;
 
    m_errorType = other.m_errorType;
    m_lineNumber = other.m_lineNumber;
 
    if (other.m_what) {
      int length = strlen(other.m_what);
      m_what = new char[length + 1];
      strncpy(m_what, other.m_what, length);
      m_what[length] = '\0';
    }
 
    if (other.m_message) {
      m_message = new QString(*other.m_message);
    }
 
    if (other.m_fileName) {
      m_fileName = new QString(*other.m_fileName);
    }
 
    if (other.m_previousExceptions) {
      m_previousExceptions = new QList<IException>(*other.m_previousExceptions);
    }
  }
 
 
  IException::~IException() throw() {
    delete [] m_what;
    m_what = NULL;
 
    m_errorType = Unknown;
 
    delete m_message;
    m_message = NULL;
 
    delete m_fileName;
    m_fileName = NULL;
 
    m_lineNumber = -1;
 
    delete m_previousExceptions;
    m_previousExceptions = NULL;
  }
 
 
  const char *IException::what() const throw() {
    return m_what;
  }
 
  void IException::append(const IException &exceptionSource) {
    if (!m_previousExceptions) {
      m_previousExceptions = new QList<IException>;
    }
 
    if (exceptionSource.m_previousExceptions) {
      m_previousExceptions->append(*exceptionSource.m_previousExceptions);
    }
 
    m_previousExceptions->append(exceptionSource);
 
    delete [] m_what;
    m_what = NULL;
    m_what = buildWhat();
  }
 
  IException::ErrorType IException::errorType() const {
    return m_errorType;
  }
 
 
  void IException::print() const {
    QString errorString = toString();
    if (errorString != "")
      cerr << errorString.toLatin1().data() << endl;
  }
 
 
  void IException::print(bool printFileInfo) const {
    QString errorString = toString(printFileInfo);
    if (errorString != "")
      cerr << errorString.toLatin1().data() << endl;
  }
 
 
  Pvl IException::toPvl() const {
    Pvl errors;
 
    QList<IException> exceptionsToConvert;
 
    if(m_previousExceptions) {
      exceptionsToConvert.append(*m_previousExceptions);
    }
    exceptionsToConvert.append(*this);
 
    for (int exceptionIndex = exceptionsToConvert.size() - 1;
         exceptionIndex >= 0;
         exceptionIndex--) {
      const IException &exception(exceptionsToConvert.at(exceptionIndex));
 
      bool exceptionIsBlank = true;
      PvlGroup errGroup("Error");
 
      errGroup += PvlKeyword("Program", Application::Name());
 
      if (exception.m_errorType != Unknown) {
        errGroup += PvlKeyword("Class",
                               errorTypeToString(exception.m_errorType));
        exceptionIsBlank = false;
      }
 
      errGroup += PvlKeyword("Code", Isis::toString(exception.m_errorType));
 
      if (exception.m_message) {
        exceptionIsBlank = false;
        QString message(*exception.m_message);
 
        if (message.size() && message[message.size() - 1] == '.')
          message = message.mid(0, message.size() - 1);
        errGroup += PvlKeyword("Message", message);
      }
 
      if (exception.m_fileName) {
        exceptionIsBlank = false;
        errGroup += PvlKeyword("File", *exception.m_fileName);
 
        if (exception.m_lineNumber != -1)
          errGroup += PvlKeyword("Line", Isis::toString(exception.m_lineNumber));
      }
 
      if (!exceptionIsBlank)
        errors.addGroup(errGroup);
    }
 
    return errors;
  }
 
 
  QString IException::toString() const {
    bool reportFileLine = true;
 
    if (Preference::Preferences().hasGroup("ErrorFacility")) {
      PvlGroup &errorFacility =
          Preference::Preferences().findGroup("ErrorFacility");
      if (errorFacility.hasKeyword("FileLine")) {
        QString fileLine = errorFacility["FileLine"][0];
        reportFileLine = (fileLine.toUpper() == "ON");
      }
    }
 
    return toString(reportFileLine);
  }
 
 
  QString IException::toString(bool includeFileInfo) const {
    QString result;
 
    bool usePvlFormat = false;
 
    if (Preference::Preferences().hasGroup("ErrorFacility")) {
      PvlGroup &errorFacility =
          Preference::Preferences().findGroup("ErrorFacility");
      if (errorFacility.hasKeyword("Format")) {
        QString format = errorFacility["Format"][0];
        usePvlFormat = (format.toUpper() == "PVL");
      }
    }
 
    if (usePvlFormat) {
      Pvl errors = toPvl();
 
      if (errors.groups() != 0) {
        stringstream stringStream;
        stringStream << errors;
        result = stringStream.str().c_str();
      }
    }
    else {
      QList<IException> exceptionsToConvert;
 
      if(m_previousExceptions) {
        exceptionsToConvert.append(*m_previousExceptions);
      }
      exceptionsToConvert.append(*this);
 
      for (int exceptionIndex = exceptionsToConvert.size() - 1;
           exceptionIndex >= 0;
           exceptionIndex--) {
        const IException &exception(exceptionsToConvert.at(exceptionIndex));
 
        // Don't put **ERROR** if there is no message or type
        if (exception.m_errorType != Unknown || exception.m_message) {
          result += "**" + errorTypeToString(exception.m_errorType) + "**";
        }
 
        bool needsPeriod = false;
        if (exception.m_message) {
          QString message(*exception.m_message);
 
          if (message.size() && message[message.size() - 1] == '.')
            message = message.mid(0, message.size() - 1);
          // There is always a **TYPE** already in the string, so prefix the
          //   message with a space.
          result += " " + message;
          needsPeriod = true;
        }
 
        if(includeFileInfo && exception.m_fileName) {
          result += " in " + *exception.m_fileName;
          if (exception.m_lineNumber != -1)
            result += " at " + Isis::toString(exception.m_lineNumber);
          needsPeriod = true;
        }
 
        if (needsPeriod)
          result += ".";
 
        if (result.size() && result[result.size() - 1] != '\n')
          result += "\n";
      }
    }
 
    return result.trimmed();
  }
 
 
  void IException::swap(IException &other) {
    std::swap(m_what, other.m_what);
    std::swap(m_errorType, other.m_errorType);
    std::swap(m_message, other.m_message);
    std::swap(m_fileName, other.m_fileName);
    std::swap(m_lineNumber, other.m_lineNumber);
    std::swap(m_previousExceptions, other.m_previousExceptions);
  }
 
 
  IException &IException::operator=(const IException &rhs) {
    IException copy(rhs);
    swap(copy);
 
    return *this;
  }
 
 
  QString IException::errorTypeToString(ErrorType type) {
    QString result;
 
    switch(type) {
      case User:
        result = "USER ERROR";
        break;
      case Programmer:
        result = "PROGRAMMER ERROR";
        break;
      case Io:
        result = "I/O ERROR";
        break;
      case Unknown:
        result = "ERROR";
        break;
    }
 
    return result;
  }
 
 
  IException::ErrorType IException::stringToErrorType(
      const QString &string) {
    ErrorType result = Unknown;
 
    if(string == "USER ERROR")
      result = User;
    else if(string == "PROGRAMMER ERROR")
      result = Programmer;
    else if(string == "I/O ERROR")
      result = Io;
 
    return result;
  }
 
 
  char *IException::buildWhat() const {
    QString whatStr = toString();
 
    char *result = new char[whatStr.size() + 1];
    strncpy(result, whatStr.toLatin1().data(), whatStr.size());
    result[whatStr.size()] = '\0';
 
    return result;
  }
 
 
  void IException::deleteEmptyMemberStrings() {
    if (m_message->size() == 0) {
      delete m_message;
      m_message = NULL;
    }
 
    if (m_fileName->size() == 0) {
      delete m_fileName;
      m_fileName = NULL;
    }
  }
}