basics/exceptions.hh

Go to the documentation of this file.

/* exceptions
 *
 * Assert
 * an exeption should be thrown with information about: file, line, function,
 * violated condition, exception name. This exception can be handled in the
 * main program.
 */

#ifndef exceptions_hh
#define exceptions_hh

#include <exception>
#include <iostream>
#include <string>
#include <cstdlib>
#include <sstream>
#include <new>

#include "outputOperator.hh"

namespace concepts {

  // ************************************************************ Stacktrace **

  class Stacktrace {
  public:
    static void print();
    static bool& doit() { return doit_; }
  private:
    static bool doit_;
  };

  // ********************************************************* ExceptionBase **

  class ExceptionBase : public std::exception,
      public OutputOperator 
  {
  public:
    ExceptionBase() throw();
    
    ExceptionBase(const std::string& message) throw()
    {
      new(this) ExceptionBase("(undefined)", -1, "(undefined)", message);
    }

    ExceptionBase(const std::string& file, const unsigned int line, 
   const std::string& function, const std::string& excName) throw();

    virtual ~ExceptionBase() throw();

    void setFields(const std::string& file, const unsigned int line, 
       const std::string& function, 
       const std::string& excName) throw();

  protected:
    virtual std::ostream& info(std::ostream& os) const throw();

    std::string file_;

    unsigned int line_;

    std::string function_;

    std::string excName_;
  };

  // ***************************************************** DimensionMismatch **

  class DimensionMismatch : public ExceptionBase {};

  // ****************************************************** IndexNotExisting **

  class IndexNotExisting : public ExceptionBase {};

  // ******************************************************** MissingFeature **

  class MissingFeature : public ExceptionBase {
  public:
    MissingFeature(const std::string& feature) throw();

    MissingFeature(const std::string& file, const unsigned int line, 
       const std::string& function, const std::string& excName, 
       const std::string& feature = std::string("")) throw();

    virtual ~MissingFeature() throw();
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();

    std::string feature_;
  };

  // ************************************************************* Assertion **

  class Assertion : public MissingFeature {
  public:
    Assertion() throw();

    Assertion(const std::string& file, const unsigned int line, 
        const std::string& function, const std::string& excName, 
        const std::string& cond) throw();

    virtual ~Assertion() throw();

    void setFieldsAssert(const std::string& file, const unsigned int line, 
       const std::string& function, 
       const std::string& excName, 
       const std::string& cond = std::string("")) throw();
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();
  };

  // ************************************************** exception_set_fields **

#ifndef __GNUC__
#  define __PRETTY_FUNCTION__ "(unknown)"
#endif

  template<class exc>
  exc exception_set_fields(exc e, const std::string& file, 
         const unsigned int line,
         const std::string& function, 
         const std::string& excName) {
    e.setFields(file, line, function, excName);
#ifdef DEBUG
    Stacktrace::print();
#endif
#ifdef __SUNPRO_CC
    std::cout << e << std::endl;
    std::exit(0);
#endif
    return e;
  }

  // ***************************************************** conceptsException **

#define conceptsException(exc) \
  exception_set_fields(exc, std::string(__FILE__), __LINE__, \
           std::string(__PRETTY_FUNCTION__), std::string(#exc))

#define CONCEPTS_SIMPLE_EXC(msg) \
  exception_set_fields(ExceptionBase(), std::string(__FILE__), __LINE__, \
           std::string(__PRETTY_FUNCTION__), std::string(msg))

  // ************************************************ exception_throw_assert **

  template<class exc>
  void exception_throw_assert(const std::string& file, int line, 
            const std::string& function,
            const std::string& exc_name, 
            const std::string& cond, exc e) {
    e.setFieldsAssert(file, line, function, exc_name, cond);
    Stacktrace::print();
#ifdef __SUNPRO_CC
    std::cout << e << std::endl;
    std::exit(0);
#else
    throw e;
#endif
  }

  // ******************************************************** conceptsAssert **

#ifndef DEBUG

#define conceptsAssert(cond, exc) { }
#else
#define conceptsAssert(cond, exc) { \
    if (!(cond)) { \
      std::stringstream errorMsg; \
      errorMsg << "by violating condition <" << #cond << ">"; \
      exception_throw_assert(std::string(__FILE__), __LINE__, \
           std::string(__PRETTY_FUNCTION__), \
                             std::string(#exc), errorMsg.str(), exc); \
    } \
  }
#endif // DEBUG

#define conceptsThrowSimpleE(msg) { \
      std::stringstream errorMsg; \
      errorMsg << msg; \
      exception_throw_assert(std::string(__FILE__), __LINE__, \
           std::string(__PRETTY_FUNCTION__), \
           std::string("SimpleException"), errorMsg.str(), concepts::Assertion()); \
  }


  // ******************************************************* conceptsAssert3 **

#ifndef DEBUG

#define conceptsAssert3(cond, exc, msg) { }
#else
#define conceptsAssert3(cond, exc, msg) { \
    if (!(cond)) { \
      std::stringstream errorMsg; \
      errorMsg << "by violating condition <" << #cond << ">, " << msg; \
      exception_throw_assert(std::string(__FILE__), __LINE__, \
           std::string(__PRETTY_FUNCTION__), \
                             std::string(#exc), errorMsg.str(), exc); \
    } \
  }
#endif // DEBUG

} // namespace

#endif // exceptions_hh