Exception.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include <exception>
#include <stdexcept>
#include <string>
 
namespace Mantid {
namespace Kernel {
namespace Exception {
 
class MANTID_KERNEL_DLL FileError : public std::runtime_error {
private:
  const std::string fileName;
  std::string outMessage;
 
public:
  FileError(const std::string &Desc, std::string FName);
  FileError(const FileError &A);
  FileError &operator=(const FileError &A);
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL ParseError final : public FileError {
private:
  const int m_lineNumber;
  std::string m_outMessage;
 
public:
  ParseError(const std::string &desc, const std::string &fileName, const int &lineNumber);
  ParseError(const ParseError &A);
  ParseError &operator=(const ParseError &A);
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL NotImplementedError final : public std::logic_error {
public:
  NotImplementedError(const std::string &);
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL NotFoundError final : public std::runtime_error {
private:
  const std::string objectName;
  std::string outMessage;
 
public:
  NotFoundError(const std::string &, std::string);
  NotFoundError(const std::string &, const int &);
  NotFoundError(const std::string &, const int64_t &);
  NotFoundError(const std::string &, const std::size_t &);
  NotFoundError(const NotFoundError &A);
  NotFoundError &operator=(const NotFoundError &A);
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL ExistsError final : public std::runtime_error {
private:
  const std::string objectName;
  std::string outMessage;
 
public:
  ExistsError(const std::string &, std::string);
  ExistsError(const ExistsError &A);
  ExistsError &operator=(const ExistsError &A);
 
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL AbsObjMethod : public std::runtime_error {
private:
  const std::string objectName;
  std::string outMessage;
 
public:
  AbsObjMethod(std::string);
  AbsObjMethod(const AbsObjMethod &A);
  AbsObjMethod &operator=(const AbsObjMethod &A);
 
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL InstrumentDefinitionError : public std::runtime_error {
private:
  const std::string objectName;
  std::string outMessage;
 
public:
  InstrumentDefinitionError(const std::string &, std::string);
  InstrumentDefinitionError(const std::string &);
  InstrumentDefinitionError(const InstrumentDefinitionError &A);
  InstrumentDefinitionError &operator=(const InstrumentDefinitionError &A);
 
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL OpenGLError : public std::runtime_error {
private:
  const std::string objectName;
  std::string outMessage;
 
public:
  OpenGLError(const std::string &, std::string);
  OpenGLError(const std::string &);
  OpenGLError(const OpenGLError &A);
  OpenGLError &operator=(const OpenGLError &A);
 
  const char *what() const noexcept override;
};
template <typename T> class MisMatch : public std::runtime_error {
private:
  const T Aval;          
  const T Bval;          
  std::string m_message; 
 
public:
  MisMatch(const T &, const T &, const std::string &);
  MisMatch(const MisMatch<T> &A);
  MisMatch<T> &operator=(const MisMatch<T> &rhs) = delete;
 
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL IndexError : public std::runtime_error {
private:
  const size_t Val;      
  const size_t maxVal;   
  std::string m_message; 
 
public:
  // Unsigned versions
  IndexError(const size_t V, const size_t B, const std::string &Place);
  IndexError(const IndexError &A);
  IndexError &operator=(const IndexError &A);
 
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL NullPointerException : public std::runtime_error {
private:
  const std::string outMessage;
 
public:
  NullPointerException(const std::string &place, const std::string &objectName);
  const char *what() const noexcept override;
};
 
class MANTID_KERNEL_DLL InternetError final : public std::runtime_error {
private:
  std::string outMessage;
  int m_errorCode; 
 
public:
  InternetError(const std::string &message, const int &errorCode = 0);
  const char *what() const noexcept override;
  const int &errorCode() const;
};
 
class MANTID_KERNEL_DLL FitSizeWarning final : public std::exception {
  std::string m_message;
 
public:
  explicit FitSizeWarning(size_t oldSize);
  FitSizeWarning(size_t oldSize, size_t newSize);
  const char *what() const noexcept override;
};
 
} // namespace Exception
} // namespace Kernel
} // namespace Mantid