dlrCommon/exception.h

Go to the documentation of this file.

#ifndef _DLR_COMMON_EXCEPTION_H_
#define _DLR_COMMON_EXCEPTION_H_

#include <cstring>
#include <exception>

// We use preprocessor macros to throw exceptions so that __LINE__
// and __FILE__ will report the correct line number and filename when
// the exception is thrown.

// Define _DLRCOMMON_VOCAL_EXCEPTIONS_ for debugging purposes if you'd
// like to print a message to stderr each time one of the DLR_THROW
// macros is called.
#ifdef _DLRCOMMON_VOCAL_EXCEPTIONS_

#include <iostream>

#define DLR_THROW(exception, functionName, message) { \
  exception exceptionInstance(message, functionName, __FILE__, __LINE__); \
  std::cerr << "DLR_THROW: " << exceptionInstance.what() << std::endl; \
  throw exceptionInstance; \
  }


#define DLR_THROW2(exception, message) { \
  exception exceptionInstance(message, __FILE__, __LINE__); \
  std::cerr << "DLR_THROW2: " << exceptionInstance.what() << std::endl; \
  throw exceptionInstance; \
  }



#define DLR_THROW3(exception, functionName, message) { \
  exception exceptionInstance(message, functionName, __FILE__, __LINE__); \
  std::cerr << "DLR_THROW3: " << exceptionInstance.what() << std::endl; \
  throw exceptionInstance; \
  }


#else // #ifdef _DLRCOMMON_VOCAL_EXCEPTIONS_


#define DLR_THROW(exception, functionName, message) { \
  throw exception(message, functionName, __FILE__, __LINE__); \
  }


#define DLR_THROW2(exception, message) { \
  throw exception(message, __FILE__, __LINE__); \
  }


#define DLR_THROW3(exception, functionName, message) { \
  throw exception(message, functionName, __FILE__, __LINE__); \
  }


#endif // #ifdef _DLRCOMMON_VOCAL_EXCEPTIONS_


#define DLR_EXCEPTION_MESSAGE_LENGTH 512


#ifndef DLR_EXCEPTION_TRACE_MESSAGE_LENGTH
#define DLR_EXCEPTION_TRACE_MESSAGE_LENGTH 512
#endif

#ifndef DLR_EXCEPTION_TRACE_REQUIRED_STACK_LEVELS
#define DLR_EXCEPTION_TRACE_REQUIRED_STACK_LEVELS 16
#endif


#define DLR_DECLARE_EXCEPTION_TYPE(ExceptionName, ParentName) \
  class ExceptionName : public ParentName { \
  public: \
    ExceptionName() throw() \
      : ParentName("", #ExceptionName) {} \
    \
    ExceptionName(const char* message) throw() \
      : ParentName(message, #ExceptionName) {} \
    \
    ExceptionName(const char* message, const char* fileName, \
                  int lineNumber) throw() \
      : ParentName(message, #ExceptionName, 0, fileName, lineNumber) {} \
    \
    ExceptionName(const char* message, const char* functionName, \
                  const char* fileName, int lineNumber) throw() \
      : ParentName(message, #ExceptionName, functionName, fileName, \
                   lineNumber) {} \
    \
    ExceptionName(const ExceptionName& source) throw() \
      : ParentName(source) {} \
    \
    virtual ~ExceptionName() throw() {} \
    \
  protected: \
    ExceptionName(const char* message, const char* childClassName) throw() \
      : ParentName(message, childClassName) {} \
    \
    ExceptionName(const char* message, const char* childClassName, \
                  const char* functionName, const char* fileName, \
                  int lineNumber) throw() \
      : ParentName(message, childClassName, functionName, fileName, \
                   lineNumber) {} \
  }


namespace dlr {

  namespace common {
    
    class Exception : public std::exception {
    public:

      Exception(const char* message) throw();


      Exception(const char* message, const char* fileName,
                int lineNumber) throw();


      Exception(const char* message, const char* functionName,
                const char* fileName, int lineNumber) throw();


      Exception(const Exception& source) throw();


      virtual ~Exception() throw() {}
    

      virtual void addTrace(const char* message) throw();

    
      virtual const char* trace() const throw() {return m_traceMessage;}


      virtual const char* what() const throw() {return m_message;}


      virtual Exception& operator=(const Exception& source) throw();

    protected:
      Exception(const char* message, const char* childClassName) throw();


      Exception(const char* message, const char* childClassName,
                const char* functionName, const char* fileName,
                int lineNumber) throw();


      char m_message[DLR_EXCEPTION_MESSAGE_LENGTH];

    
      char m_traceMessage[DLR_EXCEPTION_TRACE_REQUIRED_STACK_LEVELS
                          * DLR_EXCEPTION_TRACE_MESSAGE_LENGTH];


      size_t m_traceMessageIndex;
    
    };

  
    class IOException : public Exception {
    public:
      IOException() throw()
        : Exception("", "IOException") {}

      IOException(const char* message) throw()
        : Exception(message, "IOException") {}

      IOException(const char* message, const char* fileName,
                  int lineNumber) throw()
        : Exception(message, "IOException", 0, fileName, lineNumber) {}

      IOException(const char* message, const char* functionName,
                  const char* fileName, int lineNumber) throw()
        : Exception(message, "IOException", functionName, fileName,
                    lineNumber) {}

      IOException(const IOException& source) throw()
        : Exception(source) {}

      virtual ~IOException() throw() {}
    
    protected:
      IOException(const char* message, const char* childClassName) throw()
        : Exception(message, childClassName) {}
    
      IOException(const char* message, const char* childClassName,
                  const char* functionName, const char* fileName,
                  int lineNumber) throw()
        : Exception(message, childClassName, functionName, fileName,
                    lineNumber) {}
    };

  
    DLR_DECLARE_EXCEPTION_TYPE(IndexException, Exception);

  
    DLR_DECLARE_EXCEPTION_TYPE(LogicException, Exception);

  
    DLR_DECLARE_EXCEPTION_TYPE(NotImplementedException, Exception);

  
    DLR_DECLARE_EXCEPTION_TYPE(RunTimeException, Exception);

  
    DLR_DECLARE_EXCEPTION_TYPE(StateException, Exception);

  
    DLR_DECLARE_EXCEPTION_TYPE(ValueException, Exception);

  } // namespace common
  
} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using common::Exception;
  using common::IOException;
  using common::IndexException;
  using common::LogicException;
  using common::NotImplementedException;
  using common::RunTimeException;
  using common::StateException;
  using common::ValueException;
  
} // namespace dlr

#endif // #ifndef _DLR_COMMON_EXCEPTION_H_

---