itkExceptionObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkExceptionObject_h
#  error "Do not include itkExceptionObject.h directly,  include itkMacro.h instead."
#else // itkExceptionObject_h
 
#  include <string>
#  include <stdexcept>
 
#  include "itkSmartPointer.h"
 
namespace itk
{
class ITKCommon_EXPORT ExceptionObject : public std::exception
{
public:
  static constexpr const char * const default_exception_message = "Generic ExceptionObject";
  using Superclass = std::exception;
  ExceptionObject() noexcept;
  explicit ExceptionObject(const char * file,
                           unsigned int lineNumber = 0,
                           const char * desc = "None",
                           const char * loc = "Unknown");
  explicit ExceptionObject(std::string  file,
                           unsigned int lineNumber = 0,
                           std::string  desc = "None",
                           std::string  loc = "Unknown");
  ExceptionObject(const ExceptionObject & orig) noexcept;
 
  ~ExceptionObject() noexcept override;
 
  ExceptionObject &
  operator=(const ExceptionObject & orig) noexcept;
 
  virtual bool
  operator==(const ExceptionObject & orig);
 
  virtual const char *
  GetNameOfClass() const
  {
    return "ExceptionObject";
  }
 
  virtual void
  Print(std::ostream & os) const;
 
  virtual void
  SetLocation(const std::string & s);
 
  virtual void
  SetDescription(const std::string & s);
 
  virtual void
  SetLocation(const char * s);
 
  virtual void
  SetDescription(const char * s);
 
  virtual const char *
  GetLocation() const;
 
  virtual const char *
  GetDescription() const;
 
  virtual const char *
  GetFile() const;
 
  virtual unsigned int
  GetLine() const;
 
  const char *
  what() const noexcept override;
 
private:
  class ReferenceCounterInterface
  {
  public:
    virtual void
    Register() const = 0;
 
    virtual void
    UnRegister() const = 0;
 
    ReferenceCounterInterface();
    virtual ~ReferenceCounterInterface();
  };
  class ExceptionData;
  class ReferenceCountedExceptionData;
  SmartPointer<const ReferenceCounterInterface> m_ExceptionData;
  const ExceptionData *
  GetExceptionData() const;
};
 
inline std::ostream &
operator<<(std::ostream & os, const ExceptionObject & e)
{
  (&e)->Print(os);
  return os;
}
 
class ITKCommon_EXPORT MemoryAllocationError : public ExceptionObject
{
public:
  MemoryAllocationError() noexcept
    : ExceptionObject()
  {}
 
  MemoryAllocationError(const char * file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  MemoryAllocationError(const std::string & file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  MemoryAllocationError(const std::string & file,
                        unsigned int        lineNumber,
                        const std::string & desc,
                        const std::string & loc)
    : ExceptionObject(file, lineNumber, desc, loc)
  {}
 
  ~MemoryAllocationError() noexcept override;
 
  const char *
  GetNameOfClass() const override
  {
    return "MemoryAllocationError";
  }
};
 
class ITKCommon_EXPORT RangeError : public ExceptionObject
{
public:
  RangeError() noexcept
    : ExceptionObject()
  {}
 
  RangeError(const char * file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  RangeError(const std::string & file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  ~RangeError() noexcept override;
 
  const char *
  GetNameOfClass() const override
  {
    return "RangeError";
  }
};
 
class ITKCommon_EXPORT InvalidArgumentError : public ExceptionObject
{
public:
  InvalidArgumentError() noexcept
    : ExceptionObject()
  {}
 
  InvalidArgumentError(const char * file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  InvalidArgumentError(const std::string & file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  ~InvalidArgumentError() noexcept override;
 
  const char *
  GetNameOfClass() const override
  {
    return "InvalidArgumentError";
  }
};
 
class ITKCommon_EXPORT IncompatibleOperandsError : public ExceptionObject
{
public:
  IncompatibleOperandsError() noexcept
    : ExceptionObject()
  {}
 
  IncompatibleOperandsError(const char * file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  IncompatibleOperandsError(const std::string & file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {}
 
  ~IncompatibleOperandsError() noexcept override;
 
  const char *
  GetNameOfClass() const override
  {
    return "IncompatibleOperandsError";
  }
};
 
class ITKCommon_EXPORT ProcessAborted : public ExceptionObject
{
public:
  ProcessAborted()
    : ExceptionObject()
  {
    this->SetDescription("Filter execution was aborted by an external request");
  }
 
  ProcessAborted(const char * file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {
    this->SetDescription("Filter execution was aborted by an external request");
  }
 
  ProcessAborted(const std::string & file, unsigned int lineNumber)
    : ExceptionObject(file, lineNumber)
  {
    this->SetDescription("Filter execution was aborted by an external request");
  }
 
  ~ProcessAborted() noexcept override;
 
  const char *
  GetNameOfClass() const override
  {
    return "ProcessAborted";
  }
};
} // end namespace itk
 
#endif // itkExceptionObject_h