freExceptions.h

Go to the documentation of this file.

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

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freExceptions.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/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 __freExceptions_h
#define __freExceptions_h

#include <exception>

#include "freLogFileController.h"
#include "freElementals.h"

#include "itkExceptionObject.h"

/* Only include CExceptions on systems which provide the MFC.
 * On all other systems their is no need (and possibility) to
 * take care of these exception classes by the CatchRestNPassMacro*/
#if defined(_MFC_VER)
  #include "afx.h"
#endif

namespace FREE
{

extern LogFileController logException;

class ITKCommon_EXPORT ExceptionBase : public itk::ExceptionObject
{
public:  
        
        itkTypeMacro(ExceptionBase, itk::ExceptionObject);


        virtual std::string GetFullLocation() const;

  const char* GetErrorCode() const 
  { 
                return m_ErrorCode.c_str();
  };

  const std::string  GetExceptionTrack() const; 

  void AddTrack(const std::string&  sLocation); 
 
  virtual void Print(std::ostream& os, bool brief = false) const;

  ExceptionBase( const ExceptionBase& rExcBase );

        ExceptionBase(const std::string& sOriginCode,
          const std::string& sError = "unspecified error reason",
          const std::string& sLocation = "unknown location",
          const std::string&  sFile = "unspecified file",
          const unsigned int iLine = -1);

  virtual ~ExceptionBase() throw();

protected:
  STLStringVector m_TrackedLocations;
        
        std::string m_ErrorCode;
};


class ITKCommon_EXPORT ControllerException : public ExceptionBase
{
public:  
        itkTypeMacro(ControllerException, ExceptionBase);

  virtual void Print(std::ostream& os, bool brief = false) const;

  ControllerException( const ControllerException& rExcBase );

  ControllerException(const std::string&  sOriginCode,
                                                    const std::string&  sControllerName = "unknown controller",
                                                    const std::string&  sError = "unspecified error reason",
                                                    const std::string&  sLocation = "unknown location",
                                                    const std::string&  sFile = "unspecified file",
                                                                                        const unsigned int iLine = -1);

  
  virtual ~ControllerException() throw();

protected:
        std::string m_ControllerName;
};


class ITKCommon_EXPORT ItkException : public ExceptionBase
{
public:  
        itkTypeMacro(ItkException, ExceptionBase);

  const std::string  GetItkClassName() const { return m_ErrorCode; };

  ItkException(const ItkException& rExcBase);

        ItkException(const itk::ExceptionObject& rItkException, const std::string& sWrappingLocation = "");

  virtual ~ItkException() throw();
};


//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
static void LogException( const std::string&  sOriginCode, const std::string&  sError = "unspecified error reason",
                                                  const std::string&  sMethod = "unspecified method", const std::string&  sLocation = "unspecified location")
{
  std::string  sEntry = sOriginCode+" @ "+sMethod+" ("+sLocation+")"+": "+sError;
  logException.AddDirectEntry(sEntry);
};

//----------------------------------------------------------------------------
static void LogControllerException( const std::string&  sOriginCode,
                                                                                                                                          const std::string&  sControllerName = "unknown controller",
                                                                                                                                                const std::string&  sError = "unspecified error reason",
                                                                                                                                                const std::string&  sMethod = "unspecified method",
                                                                                                                                                const std::string&  sLocation = "unspecified location")
{
  std::string  sEntry = sOriginCode+" @ "+sMethod+" ("+sLocation+")"+" : "+sControllerName+" : "+sError;
  logException.AddDirectEntry(sEntry);
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
#ifdef __FUNCSIG__
  #define FunctionNameMacro __FUNCSIG__
#else
  #ifdef __PRETTY_FUNCTION__
    #define FunctionNameMacro __PRETTY_FUNCTION__
  #else
    #ifdef __func__
      #define FunctionNameMacro __func__
    #else
      #define FunctionNameMacro "unkown"
    #endif
  #endif
#endif

//----------------------------------------------------------------------------
        #define GetClassLocationMacro( sLocation ) \
    ::itk::OStringStream location; \
    location << this->GetNameOfClass() << "::" << FunctionNameMacro; \
                sLocation = location.str();

        #define GetStaticLocationMacro( sLocation ) \
    ::itk::OStringStream location; \
    location << "static " << FunctionNameMacro; \
                sLocation = location.str();

//----------------------------------------------------------------------------
#define catchItkNPassMacro() \
catch (itk::ExceptionObject& e) \
{ \
        std::string sLocation; \
  GetClassLocationMacro( sLocation ); \
        FREE::LogException(e.GetNameOfClass(),e.what(),FunctionNameMacro,sLocation); \
  throw FREE::ItkException(e,sLocation); \
}

#define catchItkNPassStaticMacro() \
catch (itk::ExceptionObject& e) \
{ \
        std::string sLocation; \
  GetStaticLocationMacro( sLocation ); \
        FREE::LogException(e.GetNameOfClass(),e.what(),FunctionNameMacro, sLocation); \
  throw FREE::ItkException(e,sLocation); \
}
//----------------------------------------------------------------------------
#define catchFreeNPassMacro() \
catch (FREE::ExceptionBase& e) \
{ \
        std::string sLocation; \
  GetClassLocationMacro( sLocation ); \
  e.AddTrack(sLocation); \
  FREE::logException.AddDirectEntry("Catched @ "+sLocation+" and rethrown"); \
  throw; \
}

#define catchFreeNPassStaticMacro() \
catch (FREE::ExceptionBase& e) \
{ \
        std::string sLocation; \
  GetStaticLocationMacro( sLocation ); \
  e.AddTrack(sLocation); \
  FREE::logException.AddDirectEntry("Catched @ "+sLocation+" and rethrown"); \
  throw; \
}
//----------------------------------------------------------------------------
#ifdef _MFC_VER //Catch CException only if MFC present
  #define catchRestNPassMacro( sError ) \
  catch (CException* e) \
  /*Rest of CException derivates*/ \
  { \
    TCHAR   szCause[512]; \
    std::string  sMfcError; \
    \
    e->GetErrorMessage(szCause,512); \
    sMfcError = szCause; \
    e->Delete(); \
    \
                std::string sLocation; \
                GetClassLocationMacro( sLocation ); \
                \
    FREE::LogException("CException", sMfcError, sLocation); \
                throw FREE::ExceptionBase( "CException", sMfcError, sLocation, __FILE__, __LINE__); \
  } \
  /*Char based exceptions */ \
  catch( char * str ) \
  { \
    std::string sE = str; \
                std::string sLocation; \
                GetClassLocationMacro( sLocation ); \
    FREE::LogException("Char based exception", sE, sLocation); \
                throw FREE::ExceptionBase( "Char based exception", "Error: "+sE, sLocation, __FILE__, __LINE__); \
  } \
  /*Everything else */ \
  catch (...) \
  { \
                std::string sLocation; \
                GetClassLocationMacro( sLocation ); \
          ::itk::OStringStream message; \
                message << sError; \
    FREE::LogException("Unknown exception", message.str(), sLocation); \
    throw FREE::ExceptionBase( "Unknown exception", message.str(), sLocation, __FILE__, __LINE__); \
  }
#else //MFC-free version of the macro
  #define catchRestNPassMacro( sError ) \
  /*Char based exceptions */ \
  catch( char * str ) \
  { \
    std::string sE = "Error: "; \
                sE = sE + str; \
                std::string sLocation; \
                GetClassLocationMacro( sLocation ); \
    FREE::LogException("Char based exception", sE, sLocation); \
                throw FREE::ExceptionBase( "Char based exception", sE, sLocation, __FILE__, __LINE__); \
  } \
  /*Everything else */ \
  catch (...) \
  { \
                std::string sLocation; \
                GetClassLocationMacro( sLocation ); \
          ::itk::OStringStream message; \
                message << sError; \
    FREE::LogException("Unknown exception", message.str(), sLocation); \
    throw FREE::ExceptionBase( "Unknown exception", message.str(), sLocation, __FILE__, __LINE__); \
  }
#endif

#ifdef _MFC_VER //Catch CException only if MFC present
  #define catchRestNPassStaticMacro( sError ) \
  catch (CException* e) \
  /*Rest of CException derivates*/ \
  { \
    TCHAR   szCause[512]; \
    std::string  sMfcError; \
    \
    e->GetErrorMessage(szCause,512); \
    sMfcError = szCause; \
    e->Delete(); \
    \
                std::string sLocation; \
                GetStaticLocationMacro( sLocation ); \
                \
    FREE::LogException("CException", sMfcError, sLocation); \
                throw FREE::ExceptionBase( "CException", sMfcError, sLocation, __FILE__, __LINE__); \
  } \
  /*Char based exceptions */ \
  catch( char * str ) \
  { \
    std::string sE = str; \
                std::string sLocation; \
                GetStaticLocationMacro( sLocation ); \
    FREE::LogException("Char based exception", sE, sLocation); \
                throw FREE::ExceptionBase( "Char based exception", "Error: "+sE, sLocation, __FILE__, __LINE__); \
  } \
  /*Everything else */ \
  catch (...) \
  { \
                std::string sLocation; \
                GetStaticLocationMacro( sLocation ); \
          ::itk::OStringStream message; \
                message << sError; \
    FREE::LogException("Unknown exception", message.str(), sLocation); \
    throw FREE::ExceptionBase( "Unknown exception", message.str(), sLocation, __FILE__, __LINE__); \
  }
#else //MFC-free version of the macro
  #define catchRestNPassStaticMacro( sError ) \
  /*Char based exceptions */ \
  catch( char * str ) \
  { \
    std::string sE = "Error: "; \
                sE = sE + str; \
                std::string sLocation; \
                GetStaticLocationMacro( sLocation ); \
    FREE::LogException("Char based exception", sE, sLocation); \
                throw FREE::ExceptionBase( "Char based exception", sE, sLocation, __FILE__, __LINE__); \
  } \
  /*Everything else */ \
  catch (...) \
  { \
                std::string sLocation; \
                GetStaticLocationMacro( sLocation ); \
          ::itk::OStringStream message; \
                message << sError; \
    FREE::LogException("Unknown exception", message.str(), sLocation); \
    throw FREE::ExceptionBase( "Unknown exception", message.str(), sLocation, __FILE__, __LINE__); \
  }
#endif

//----------------------------------------------------------------------------
#define catchAllNPassMacro( sError ) \
catchFreeNPassMacro() \
catchItkNPassMacro() \
catchRestNPassMacro(sError)

#define catchAllNPassStaticMacro( sError ) \
catchFreeNPassStaticMacro() \
catchItkNPassStaticMacro() \
catchRestNPassStaticMacro(sError)

//----------------------------------------------------------------------------
#define throwExceptionMacro( x ) \
{ \
        std::string sLocation; \
        GetClassLocationMacro( sLocation ); \
  ::itk::OStringStream message; \
  message << x; \
        FREE::LogException("FREE Exception", message.str(), sLocation); \
        throw FREE::ExceptionBase("FREE Exception", message.str(), sLocation, __FILE__, __LINE__); \
} 

#define throwStaticExceptionMacro( x ) \
{ \
        std::string sLocation; \
        GetStaticLocationMacro( sLocation ); \
  ::itk::OStringStream message; \
  message << x; \
        FREE::LogException("FREE Exception", message.str(), sLocation); \
        throw FREE::ExceptionBase("FREE Exception", message.str(), sLocation, __FILE__, __LINE__); \
} 

//----------------------------------------------------------------------------
#define throwCtrlExceptionMacro(sOrigin, sError) \
{ \
        std::string sLocation; \
        GetClassLocationMacro( sLocation ); \
  ::itk::OStringStream message; \
  message << sError; \
        FREE::LogControllerException( sOrigin, this->ControllerID(), message.str(), sLocation); \
        throw FREE::ControllerException( sOrigin, this->ControllerID(), message.str(), sLocation, __FILE__, __LINE__); \
}

} //end of namespace free
#endif

---