itkExceptionObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 itkMacro_h
#error "Do not include itkExceptionObject.h directly,  include itkMacro.h instead."
#else // itkMacro_h

#ifndef itkExceptionObject_h
#define itkExceptionObject_h

#include <string>
#include <stdexcept>

#include "itkSmartPointer.h"

namespace itk
{
class ITKCommon_EXPORT ExceptionObject:public std::exception
{
public:
  typedef std::exception Superclass;
  ExceptionObject();
  explicit ExceptionObject(const char *file, unsigned int lineNumber = 0,
                           const char *desc = "None", const char *loc = "Unknown");
  explicit ExceptionObject(const std::string & file, unsigned int lineNumber = 0,
                           const std::string & desc = "None",
                           const std::string & loc = "Unknown");
  ExceptionObject(const ExceptionObject & orig);

  virtual ~ExceptionObject()
  ITK_NOEXCEPT;

  ExceptionObject & operator=(const ExceptionObject & orig);

  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;

  virtual const char * what() const ITK_NOEXCEPT ITK_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, ExceptionObject & e)
{
  ( &e )->Print(os);
  return os;
}

class ITKCommon_EXPORT MemoryAllocationError:public ExceptionObject
{
public:
  MemoryAllocationError():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) {}

  virtual ~MemoryAllocationError() ITK_NOEXCEPT;

  virtual const char * GetNameOfClass() const ITK_OVERRIDE
  { return "MemoryAllocationError"; }
};

class ITKCommon_EXPORT RangeError:public ExceptionObject
{
public:
  RangeError():ExceptionObject() {}

  RangeError(const char *file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  RangeError(const std::string & file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  virtual ~RangeError() ITK_NOEXCEPT;

  virtual const char * GetNameOfClass() const ITK_OVERRIDE
  { return "RangeError"; }
};

class ITKCommon_EXPORT InvalidArgumentError:public ExceptionObject
{
public:
  InvalidArgumentError():ExceptionObject() {}

  InvalidArgumentError(const char *file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  InvalidArgumentError(const std::string & file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  virtual ~InvalidArgumentError() ITK_NOEXCEPT;

  virtual const char * GetNameOfClass() const ITK_OVERRIDE
  { return "InvalidArgumentError"; }
};

class ITKCommon_EXPORT IncompatibleOperandsError:public ExceptionObject
{
public:
  IncompatibleOperandsError():ExceptionObject() {}

  IncompatibleOperandsError(const char *file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  IncompatibleOperandsError(const std::string & file, unsigned int lineNumber):ExceptionObject(file, lineNumber) {}

  virtual ~IncompatibleOperandsError() ITK_NOEXCEPT;

  virtual const char * GetNameOfClass() const ITK_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");
  }

  virtual ~ProcessAborted()  ITK_NOEXCEPT;

  virtual const char * GetNameOfClass() const ITK_OVERRIDE
  { return "ProcessAborted"; }
};
} // end namespace itk

#endif //itkExceptionObject_h

#endif //itkMacro_h