itkExceptionObject.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkExceptionObject.h,v $
  Language:  C++
  Date:      $Date: 2002/04/18 14:25:14 $
  Version:   $Revision: 1.26 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkExceptionObject_h
#define __itkExceptionObject_h

#include <string>
#include <stdexcept>

#include "itkWin32Header.h"


namespace itk
{

class ITK_EXPORT ExceptionObject : public std::exception
{
public:
  ExceptionObject(const char *file="Unknown", unsigned int lineNumber=0,
                  const char *desc="None", const char *loc="Unknown")
  {
    m_Location = loc;
    m_Description = desc;
    m_File = file;
    m_Line = lineNumber;
  };
  ExceptionObject(const std::string& file, unsigned int lineNumber,
                  const std::string& desc="None",
                  const std::string& loc="Unknown")
  {
    m_Location = loc;
    m_Description = desc;
    m_File = file;
    m_Line = lineNumber;
  };
  ExceptionObject( const ExceptionObject &orig )
  {
    m_Location    = orig.m_Location;
    m_Description = orig.m_Description;
    m_File = orig.m_File;
    m_Line = orig.m_Line;
  }
  
  virtual ~ExceptionObject() throw() {}

  ExceptionObject &operator= ( const ExceptionObject &orig )
  {
    m_Location    = orig.m_Location;
    m_Description = orig.m_Description;
    m_File = orig.m_File;
    m_Line = orig.m_Line;
    return *this;
  }
  
  virtual bool operator==( const ExceptionObject &orig )
  {
    if ( m_Location    == orig.m_Location &&
         m_Description == orig.m_Description &&
         m_File == orig.m_File &&
         m_Line == orig.m_Line) 
      {
      return true;
      }
    else 
      {
      return false;
      }
  }
          
  virtual const char *GetNameOfClass() const 
    {return "ExceptionObject";}

  virtual void Print(std::ostream& os) const;

  virtual void SetLocation(const std::string& s)    
    { m_Location = s;    }
  virtual void SetDescription(const std::string& s) 
    { m_Description = s; }
  virtual void SetLocation(const char * s)          
    { m_Location = s;    }
  virtual void SetDescription (const char *s)       
    { m_Description = s; }
  virtual const char *GetLocation()    const 
    { return m_Location.c_str();    }
  virtual const char *GetDescription() const 
    { return m_Description.c_str(); }
  
  virtual const char *GetFile()    const 
    { return m_File.c_str(); }

  virtual unsigned int GetLine() const 
    { return m_Line; }
  
  virtual const char* what() const throw()
    { return m_Description.c_str(); }
  
private:
  std::string  m_Location;
  std::string  m_Description;
  std::string  m_File;
  unsigned int m_Line;
 
};

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

class 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() throw() {}

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

};

class 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() throw() {}

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

class 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() throw() {}

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


} // end namespace itk

#endif

---