ErrorException.h

Go to the documentation of this file.

#ifndef CARMA_UTIL_ERROR_EXCEPTION_H
#define CARMA_UTIL_ERROR_EXCEPTION_H

#include <string>
#include <iosfwd>

#include <log4cpp/Priority.hh>

#include "carma/util/BaseException.h"


namespace carma {
    namespace util {

class ErrorException: public BaseException {
public:
    
    ErrorException(const std::string& msg, const char* filename, int lineNo);


    ErrorException(const std::ostringstream& msg, 
            const char* filename, int lineNo);


    ErrorException(const ErrorException& errorException);

    virtual ~ErrorException() throw();


    ErrorException & operator=( const ErrorException & rhs );

    virtual const char* what() const throw();


    virtual ::std::string getLogString( ) const;


    void report() const;

    void log(log4cpp::Priority::PriorityLevel priority) const;

    std::string getErrorMessage() const ;

protected:
    explicit ErrorException( );

private:
    void swap( ErrorException & rhs );

    void buildErrorMsg( const char * filename );

    const char * errorMsg_;  // Full message w/line# and file name
};

} }  // End namespace carma::util  


::std::ostream & operator<<( ::std::ostream &         os,
                             const ::std::exception & error );


#define CARMA_ERROR(y)  CARMA_EXCEPTION(carma::util::ErrorException,(y))

// Macros added by EML to allow error messages to be contructed inline

#define ThrowCarmaError(text) \
{\
  std::ostringstream _macroOs; \
  _macroOs << text;\
  throw CARMA_ERROR(_macroOs.str());\
}

#define ThrowCarmaUserException(text) \
{\
  std::ostringstream _macroOs; \
  _macroOs << text;\
  throw CARMA_EXCEPTION( carma::util::UserException, _macroOs.str().c_str() );\
}

#define CARMA_ASSERT( assertion )                                           \
    do {                                                                    \
        if ( !(assertion) )                                                 \
            throw CARMA_ERROR( #assertion );                                \
    } while ( false )

// ADB: Throw an arbitrary exception ala Erik's methods above.
// Note that I 'swallow the semicolon' with the do while loop
// to protect against a common macroism.  Google it for details.
#define ThrowCarmaException(exception, text)                 \
    do {                                                     \
        std::ostringstream _macroOs;                         \
        _macroOs << text;                                    \
        throw CARMA_EXCEPTION( exception, _macroOs.str() );  \
    } while ( false )      

// ADB: Create a typed derivative error exception 
// sans boilerplate.  Note the derived exception will 
// live in the namespace this macro is called in.
#define MAKE_DERIVED_ERROR_EXCEPTION(T)             \
                                                    \
class T : public carma::util::ErrorException {      \
public:                                             \
                                                    \
    T( const std::string & os,                      \
       const char * filename,                       \
       const int lineNumber) :                      \
        carma::util::ErrorException(                \
            ( std::string )( #T ) + ": " + os,      \
            filename,                               \
            lineNumber)                             \
    { };                                            \
                                                    \
    T( const std::ostringstream & os,               \
       const char * filename,                       \
       const int lineNumber) :                      \
        carma::util::ErrorException(                \
            ( std::string )( #T ) + ": " + os.str(),\
            filename,                               \
            lineNumber )                            \
    { };                                            \
                                                    \
    virtual ~T() throw ()                           \
    { };                                            \
                                                    \
};

#endif // CARMA_UTIL_ERROR_EXCEPTION_H