Exception.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/Exception.h"
#include "MantidKernel/DllConfig.h"
#include <sstream>
#include <utility>
 
namespace Mantid::Kernel::Exception {
//-------------------------
// FileError
//-------------------------
FileError::FileError(const std::string &Desc, std::string FName)
    : std::runtime_error(Desc), fileName(std::move(FName)) {
  outMessage = std::string(std::runtime_error::what()) + " in \"" + fileName + "\"";
}
 
FileError::FileError(const FileError &A) : std::runtime_error(A), fileName(A.fileName) {}
 
const char *FileError::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// ParseError
//-------------------------
ParseError::ParseError(const std::string &desc, const std::string &fileName, const int &lineNumber)
    : FileError(desc, fileName), m_lineNumber(lineNumber) {
  std::stringstream ss;
  ss << FileError::what() << " on line " << m_lineNumber;
  m_outMessage = ss.str();
}
 
ParseError::ParseError(const ParseError &A) : FileError(A), m_lineNumber(A.m_lineNumber) {}
 
const char *ParseError::what() const noexcept { return m_outMessage.c_str(); }
 
//-------------------------
// NotImplementedError
//-------------------------
NotImplementedError::NotImplementedError(const std::string &Desc) : std::logic_error(Desc) {}
 
const char *NotImplementedError::what() const noexcept { return std::logic_error::what(); }
 
//-------------------------
// NotFoundError
//-------------------------
NotFoundError::NotFoundError(const std::string &Desc, std::string ObjectName)
    : std::runtime_error(Desc), objectName(std::move(ObjectName)) {
  outMessage = std::string(std::runtime_error::what()) + " search object '" + objectName + "'";
}
 
NotFoundError::NotFoundError(const std::string &Desc, const int &ObjectNum) : std::runtime_error(Desc) {
  std::stringstream ss;
  std::string obName;
  ss << ObjectNum;
  ss >> obName;
  outMessage = std::string(std::runtime_error::what()) + " search object '" + obName + "'";
}
 
NotFoundError::NotFoundError(const std::string &Desc, const int64_t &ObjectNum) : std::runtime_error(Desc) {
  std::stringstream ss;
  std::string obName;
  ss << ObjectNum;
  ss >> obName;
  outMessage = std::string(std::runtime_error::what()) + " search object '" + obName + "'";
}
 
NotFoundError::NotFoundError(const std::string &Desc, const std::size_t &ObjectNum) : std::runtime_error(Desc) {
  std::stringstream ss;
  std::string obName;
  ss << ObjectNum;
  ss >> obName;
  outMessage = std::string(std::runtime_error::what()) + " search object '" + obName + "'";
}
 
NotFoundError::NotFoundError(const NotFoundError &A) : std::runtime_error(A), objectName(A.objectName) {}
 
const char *NotFoundError::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// ExistsError
//-------------------------
ExistsError::ExistsError(const std::string &Desc, std::string ObjectName)
    : std::runtime_error(Desc), objectName(std::move(ObjectName)) {
  outMessage = std::string(std::runtime_error::what()) + " search object '" + objectName + "'";
}
 
ExistsError::ExistsError(const ExistsError &A) : std::runtime_error(A), objectName(A.objectName) {}
 
const char *ExistsError::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// AbsObjMethod
//-------------------------
AbsObjMethod::AbsObjMethod(std::string ObjectName) : std::runtime_error(""), objectName(std::move(ObjectName)) {
  outMessage = std::string("AbsObjMethod object: ") + objectName;
}
 
AbsObjMethod::AbsObjMethod(const AbsObjMethod &A) : std::runtime_error(A), objectName(A.objectName) {}
 
const char *AbsObjMethod::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// InstrumentDefinitionError
//-------------------------
InstrumentDefinitionError::InstrumentDefinitionError(const std::string &Desc, std::string ObjectName)
    : std::runtime_error(Desc), objectName(std::move(ObjectName)) {
  outMessage = std::string(std::runtime_error::what()) + " while searching for " + objectName +
               ". See http://docs.mantidproject.org/concepts/InstrumentDefinitionFile for IDF syntax.";
}
 
InstrumentDefinitionError::InstrumentDefinitionError(const std::string &Desc) : std::runtime_error(Desc) {
  outMessage = std::string(std::runtime_error::what());
}
 
InstrumentDefinitionError::InstrumentDefinitionError(const InstrumentDefinitionError &A)
    : std::runtime_error(A), objectName(A.objectName) {}
 
const char *InstrumentDefinitionError::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// OpenGLError
//-------------------------
OpenGLError::OpenGLError(const std::string &Desc, std::string ObjectName)
    : std::runtime_error(Desc), objectName(std::move(ObjectName)) {
  outMessage = std::string(std::runtime_error::what()) + " rendering " + objectName;
}
 
OpenGLError::OpenGLError(const std::string &Desc) : std::runtime_error(Desc) {
  outMessage = std::string(std::runtime_error::what());
}
 
OpenGLError::OpenGLError(const OpenGLError &A) : std::runtime_error(A), objectName(A.objectName) {}
 
const char *OpenGLError::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// MisMatch
//-------------------------
 
template <typename T>
MisMatch<T>::MisMatch(const T &A, const T &B, const std::string &Place)
    : std::runtime_error(Place), Aval(A), Bval(B)
{
  std::stringstream cx;
  cx << Place << " Item A!=B " << Aval << " " << Bval << " ";
  m_message = cx.str();
}
 
template <typename T>
MisMatch<T>::MisMatch(const MisMatch<T> &A)
    : std::runtime_error(A), Aval(A.Aval), Bval(A.Bval)
{}
 
template <typename T>
const char *MisMatch<T>::what() const noexcept
{
  return m_message.c_str();
}
 
template class MANTID_KERNEL_DLL MisMatch<int>;
template class MANTID_KERNEL_DLL MisMatch<size_t>;
 
//-------------------------
// Index Error class
//-------------------------
 
IndexError::IndexError(const size_t V, const size_t B, const std::string &Place)
    : std::runtime_error(Place), Val(V), maxVal(B) {
  std::stringstream cx;
  cx << "IndexError: " << Place << " " << Val << " :: 0 <==> " << maxVal;
  m_message = cx.str();
}
 
IndexError::IndexError(const IndexError &A) : std::runtime_error(A), Val(A.Val), maxVal(A.maxVal) {}
 
const char *IndexError::what() const noexcept { return m_message.c_str(); }
 
//-------------------------
// NullPointerException class
//-------------------------
 
NullPointerException::NullPointerException(const std::string &place, const std::string &objectName)
    : std::runtime_error(place),
      outMessage("Attempt to dereference zero pointer (" + objectName + ") in function " + place) {}
 
const char *NullPointerException::what() const noexcept { return outMessage.c_str(); }
 
//-------------------------
// InternetError Error class
//-------------------------
 
InternetError::InternetError(const std::string &message, const int &errorCode) : std::runtime_error(message) {
  std::stringstream cx;
  cx << "InternetError: ";
  if (errorCode != 0) {
    cx << "[" << errorCode << "] ";
  }
  cx << message;
  outMessage = cx.str();
  m_errorCode = errorCode;
}
 
const char *InternetError::what() const noexcept { return outMessage.c_str(); }
 
const int &InternetError::errorCode() const { return m_errorCode; }
 
//-------------------------
// FitSizeError Error class
//-------------------------
 
FitSizeWarning::FitSizeWarning(size_t oldSize)
    : std::exception(),
      m_message("Number of fitting parameters is different from original value of " + std::to_string(oldSize)) {}
 
FitSizeWarning::FitSizeWarning(size_t oldSize, size_t newSize)
    : std::exception(), m_message("Number of fitting parameters changed from " + std::to_string(oldSize) + " to " +
                                  std::to_string(newSize)) {}
 
const char *FitSizeWarning::what() const noexcept { return m_message.c_str(); }
 
} // namespace Mantid::Kernel::Exception