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
 *
 *         https://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
#define itkExceptionObject_h
 
// NOTE: This itkExceptionObject.h file is included by itkMacro.h, and should never be included directly.
#ifndef allow_inclusion_of_itkExceptionObject_h
#  error "Do not include itkExceptionObject.h directly,  include itkMacro.h instead."
#endif
 
#include <memory> // For shared_ptr.
#include <string>
#include <typeinfo>
#include <type_traits>
 
namespace itk
{
 
class LightObject;

class ITKCommon_EXPORT ExceptionObject : public std::exception
{
public:
  static constexpr const char * const default_exception_message = "Generic ExceptionObject";
  using Superclass = std::exception;

  ExceptionObject() noexcept = default;
 
  explicit ExceptionObject(std::string         file,
                           unsigned int        lineNumber,
                           std::string         description,
                           std::string         location,
                           const LightObject * thrower);
 
  explicit ExceptionObject(std::string  file,
                           unsigned int lineNumber = 0,
                           std::string  description = "None",
                           std::string  location = {},
                           const void * thrower = nullptr);

  ExceptionObject(const ExceptionObject &) noexcept = default;

  ExceptionObject(ExceptionObject &&) noexcept = default;

  ExceptionObject &
  operator=(const ExceptionObject &) noexcept = default;

  ExceptionObject &
  operator=(ExceptionObject &&) noexcept = default;

  ~ExceptionObject() override;

  virtual bool
  operator==(const ExceptionObject & orig) const;
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(ExceptionObject);

  itkVirtualGetNameOfClassMacro(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);
 
 
  [[nodiscard]] virtual const char *
  GetLocation() const;
 
  [[nodiscard]] virtual const char *
  GetDescription() const;

  [[nodiscard]] virtual const char *
  GetFile() const;

  [[nodiscard]] virtual unsigned int
  GetLine() const;

  [[nodiscard]] const char *
  what() const noexcept override;
 
private:
  class ExceptionData; // Defined in .cxx
 
  std::shared_ptr<const ExceptionData> m_ExceptionData;
};

inline std::ostream &
operator<<(std::ostream & os, const ExceptionObject & e)
{
  e.Print(os);
  return os;
}


class ITKCommon_EXPORT MemoryAllocationError : public ExceptionObject
{
public:
  // Inherit the constructors from its base class.
  using ExceptionObject::ExceptionObject;

  itkOverrideGetNameOfClassMacro(MemoryAllocationError);
};

class ITKCommon_EXPORT RangeError : public ExceptionObject
{
public:
  // Inherit the constructors from its base class.
  using ExceptionObject::ExceptionObject;

  itkOverrideGetNameOfClassMacro(RangeError);
};

class ITKCommon_EXPORT InvalidArgumentError : public ExceptionObject
{
public:
  // Inherit the constructors from its base class.
  using ExceptionObject::ExceptionObject;

  itkOverrideGetNameOfClassMacro(InvalidArgumentError);
};

class ITKCommon_EXPORT IncompatibleOperandsError : public ExceptionObject
{
public:
  // Inherit the constructors from its base class.
  using ExceptionObject::ExceptionObject;

  itkOverrideGetNameOfClassMacro(IncompatibleOperandsError);
};

class ITKCommon_EXPORT ProcessAborted : public ExceptionObject
{
public:
  ProcessAborted()
    : ExceptionObject()
  {
    this->SetDescription("Filter execution was aborted by an external request");
  }

  ProcessAborted(std::string file, unsigned int lineNumber)
    : ExceptionObject(std::move(file), lineNumber, "Filter execution was aborted by an external request")
  {}

  itkOverrideGetNameOfClassMacro(ProcessAborted);
};
 
// Forward declaration in Macro.h, implementation here to avoid circular dependency
template <typename TTarget, typename TSource>
TTarget
itkDynamicCastInDebugMode(TSource x)
{
#ifndef NDEBUG
  if (x == nullptr)
  {
    return nullptr;
  }
  auto rval = dynamic_cast<TTarget>(x);
  if (rval == nullptr)
  {
    itkGenericExceptionMacro("Failed dynamic cast to " << typeid(TTarget).name()
                                                       << " object type = " << x->GetNameOfClass());
  }
  return rval;
#else
  return static_cast<TTarget>(x);
#endif
}
 
} // end namespace itk
#endif // itkExceptionObject_h