jafarException.hpp

/* $Id$ */

#ifndef KERNEL_JAFAR_EXCEPTION_HPP
#define KERNEL_JAFAR_EXCEPTION_HPP

#include <string>

#include <list>

#include <iostream>

#include "kernel/jafarMacro.hpp"

namespace jafar {

  namespace kernel {


     /* Obtain a backtrace and print it to stdout. */
     std::string get_system_trace ();
     void print_system_trace();

    class Exception {

    public:

      virtual std::string what() const throw();

      void addTrace(std::string const& module_, std::string const& file_, int line_, std::string const& message_ = "");

      Exception(const std::string& message_, 
                const std::string& module_, const std::string& id_, 
                const std::string& file_, int line_) throw();

      virtual ~Exception() throw();

    protected:

      std::string _what;

       std::list<std::string> trace;

      friend std::ostream& operator <<(std::ostream& s, const Exception& e);

    }; // end class Exception

    std::ostream& operator <<(std::ostream& s, const Exception& e);

    class JafarException : public jafar::kernel::Exception {

    public:

      enum ExceptionId {
  ASSERT,            
        PRECONDITION,      
        POSTCONDITION,     
        INVARIANT,         
        RUN_TIME,          
        IO_STREAM,         
  NUMERIC,           
  INVALID_PARAM      
      };

      JafarException(ExceptionId id_, const std::string& message_, 
                     const std::string& module_, const std::string& file_, int line_) throw();

      virtual ~JafarException() throw();

      ExceptionId getExceptionId() const throw();

    protected:

      ExceptionId id;

      static std::string exceptionIdToString(ExceptionId id_) throw();      

    };

    template<typename T>
    class InvalidParamException : public JafarException {

    public:

      InvalidParamException(const T& value, const std::string& message_,
          const std::string& module_, const std::string& file_, int line_) : 
  JafarException(INVALID_PARAM, message_, module_, file_, line_),
  m_value(value) {}

      T value() const {return m_value;}

    private:
      
      T m_value;

    };

    template <typename T>
    void throwInvalidParamException(const T& value, const std::string& message_,
            const std::string& module_, const std::string& file_, int line_) 
    {
      throw InvalidParamException<T>(value, message_,
             module_, file_, line_);
    }

  } // namespace kernel
} // namespace jafar

// automatically include macros
#include "kernel/jafarMacro.hpp"

#endif // KERNEL_JAFAR_EXCEPTION_HPP