Exception.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*    Copyright 2003 - 2008 Sandia Corporation.                       */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#ifndef STK_UTIL_PARALLEL_Exception_hpp
#define STK_UTIL_PARALLEL_Exception_hpp

/*--------------------------------------------------------------------*/
#include <stdexcept>
#include <exception>
#include <new>
#include <typeinfo>
#include <string>
#include <vector>
// #include <iostream> // for std::cerr
#include <sstream>

#include <stk_util/stk_config.h>
#if defined( STK_HAS_MPI )
#include <mpi.h>
#endif

#include <stk_util/environment/ReportHandler.hpp>

#include <stk_util/util/FeatureTest.hpp>
#include <stk_util/diag/String.hpp>
#include <stk_util/diag/StringUtil.hpp>
#include <stk_util/diag/Trace.hpp>

namespace sierra {


class ExParallel;

void register_stl_parallel_exceptions();

void set_exception();

void set_exception(std::exception &x);

void set_exception(ExParallel &x);

void sierra_exception_throw();

void throw_copy(const std::exception &x, const std::string &message);

void parallel_throw(MPI_Comm mpi_comm);


class ParallelThrowRegistry
{
public:
  static ParallelThrowRegistry &instance();

  static bool areExceptionsRegistered() {
    return !ParallelThrowRegistry::instance().m_registry.empty();
  }

  template<class T>
  ExParallel &registerException() {
    T *x = new T();
    register_exception_a(typeid(T), x);
    register_exception_a(typeid(typename T::BaseExceptionType), x);
    return *x;
  }

  ExParallel *findException(const std::type_info &exception_type);

private:
  ExParallel &register_exception_a(const std::type_info &parallel_exception_type, ExParallel *exception);

private:
  class Registry : public std::vector<std::pair<const std::type_info *, ExParallel *> > 
  {
  public:
    Registry();

    ~Registry();
  };

  Registry    m_registry;     
};


class ExParallel
{
protected:
  ExParallel()
    : m_descriptionStream(),
      m_whatBuffer(),
      m_traceback(Diag::Trace::printTraceback(Diag::Trace::Traceback::snapshot())),
      m_parallel(-1)
  {
    if (ParallelThrowRegistry::areExceptionsRegistered())
      sierra_exception_throw();
  }

  explicit ExParallel(const std::string & message, int parallel = -1)
    : m_descriptionStream(),
      m_whatBuffer(),
      m_traceback(Diag::Trace::printTraceback(Diag::Trace::Traceback::snapshot())),
      m_parallel(parallel)
  {
    m_descriptionStream << message;
    if (ParallelThrowRegistry::areExceptionsRegistered())
      sierra_exception_throw();
  }

  ExParallel(const ExParallel &x)
    : m_descriptionStream(),
      m_whatBuffer(),
      m_traceback(x.m_traceback),
      m_parallel(x.m_parallel)
  {
    m_descriptionStream << x.m_descriptionStream.str();
  }

public:
  virtual ~ExParallel()
  {}

  virtual const char *what() const throw() {
    try {
      m_whatBuffer = m_descriptionStream.str();
      return m_whatBuffer.c_str();
    }
    catch(...) {
      return NULL;
    }
  }

  ExParallel &clear() {
    m_descriptionStream.str("");
    m_traceback.clear();
    m_parallel = -1;
    return *this;
  }

  ExParallel &setDescription(const std::string &description) {
    clear();
    m_descriptionStream << description;
    return *this;
  }

  std::string getDescription() const{
    return m_descriptionStream.str();
  }

  std::ostringstream &getDescriptionStream() {
    return m_descriptionStream;
  }

  const std::ostringstream &getDescriptionStream() const {
    return m_descriptionStream;
  }

  ExParallel &setTraceback(const std::string &traceback) {
    m_traceback = traceback;
    return *this;
  }

  const std::string &getTraceback() const {
    return m_traceback;
  }

  ExParallel &setParallel(int parallel) {
    m_parallel = parallel;
    return *this;
  }

  int getParallel() const {
    return m_parallel;
  }


  bool isParallel() const {
    return m_parallel != -1;
  }

  ExParallel &operator<<(std::ostream& (*f)(std::ostream&)) {
    f(m_descriptionStream);
    return *this;
  }

  template<class U>
  ExParallel &operator<<(const U &t) {
    m_descriptionStream << t;
    return *this;
  }

  virtual void throw_copy() const = 0;

  virtual void parallel_handler();

private:
  std::ostringstream  m_descriptionStream;    
  mutable std::string m_whatBuffer;     
  std::string   m_traceback;      
  int     m_parallel;     
};


template<class T>
class ExTemp : public ExParallel, public T
{
public:
  typedef ExTemp<T> ParallelExceptionType;    
  typedef T BaseExceptionType;        

  ExTemp()
    : ExParallel(),
      T()
  {}

  explicit ExTemp(const std::string &message)
    : ExParallel(message),
      T()
  {}

  ExTemp(const ExTemp & x)
    : ExParallel(static_cast<const ExParallel &>(x)),
      T(static_cast<const T &>(x))
  {}

  virtual ~ExTemp() throw()
  {}

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

  ExTemp &operator<<(std::ostream& (*f)(std::ostream&)) {
    f(getDescriptionStream());
    return *this;
  }

  template<class U>
  ExTemp &operator<<(const U &t) {
    getDescriptionStream() << t;
    return *this;
  }

  virtual void throw_copy() const {
    ParallelExceptionType t(*this);

//    std::cerr << "throwing " << this->what() << std::endl
//              << "      as " << t.what();
    throw t;
  }

  static void registerException() {
#ifdef SIERRA_TEMPLATE_CALL_BUG
    ParallelThrowRegistry::instance().template registerException<ExTemp>();
#else
    ParallelThrowRegistry::instance().registerException<ExTemp>();
#endif
  }
};


template<class T>
class ExTemp1 : public ExParallel, public T
{
public:
  typedef ExTemp1<T> ParallelExceptionType;   
  typedef T BaseExceptionType;        

  ExTemp1()
    : ExParallel(),
      T(std::string())
  {}

  explicit ExTemp1(const std::string & message)
    : ExParallel(message),
      T(message)
  {}

  ExTemp1(const ExTemp1 & x)
    : ExParallel(static_cast<const ExParallel &>(x)),
      T(static_cast<const T &>(x))
  {}

  virtual ~ExTemp1() throw()
  {}

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

  ExTemp1 &operator<<(std::ostream& (*f)(std::ostream&)) {
    f(getDescriptionStream());
    return *this;
  }


  template<class U>
  ExTemp1 &operator<<(const U &t) {
    getDescriptionStream() << t;
    return *this;
  }

  virtual void throw_copy() const {
    ParallelExceptionType t(*this);

//    std::cerr << "throwing " << this->what() << std::endl
//              << "      as " << t.what();
    throw t;
  }

  static ExParallel &registerException() {
#ifdef SIERRA_TEMPLATE_CALL_BUG
    return ParallelThrowRegistry::instance().template registerException<ExTemp1>();
#else
    return ParallelThrowRegistry::instance().registerException<ExTemp1>();
#endif
  }
};

typedef ExTemp<std::exception>    Exception;    
typedef ExTemp<std::bad_exception>  BadException;   
typedef ExTemp<std::bad_alloc>    BadAlloc;   
typedef ExTemp<std::bad_typeid>   BadTypeid;    
typedef ExTemp<std::bad_cast>   BadCast;    
typedef ExTemp1<std::ios_base::failure> IosBaseFailure;   
typedef ExTemp1<std::logic_error> LogicError;   
typedef ExTemp1<std::domain_error>  DomainError;    
typedef ExTemp1<std::invalid_argument>  InvalidArgument;  
typedef ExTemp1<std::length_error>  LengthError;    
typedef ExTemp1<std::out_of_range>  OutOfRange;   
typedef ExTemp1<std::runtime_error> RuntimeError;   
typedef ExTemp1<std::range_error> RangeError;   
typedef ExTemp1<std::overflow_error>  OverflowError;    
typedef ExTemp1<std::underflow_error> UnderflowError;   

//----------------------------------------------------------------------

class runtime_user_error : public std::runtime_error
{
public:
  explicit runtime_user_error(const std::string &message) throw()
   : std::runtime_error(message)
  {}

  runtime_user_error(const runtime_user_error &x) throw()
    : std::runtime_error(x)
  {}

  virtual ~runtime_user_error() throw ()
  {}
};

typedef ExTemp1<runtime_user_error> RuntimeUserError;


} // namepace sierra

// DO NOT USE ParallelStackTrace, unless you know that the exception will be thrown in
// parallel.  This is a magic string used by the parallel_throw routine that makes
// sure the printout will only be done on processor 0.  Since the exception is
// parallel there is no reason to print the same message many times.
#define StackTraceMessage "  exception thrown from "
#define ParallelStackTraceMessage "  parallel exception thrown from "
#define ParallelStackTrace std::string(std::string(ParallelStackTraceMessage) + stk_classic::source_relative_path(STR_TRACE))

#endif // STK_UTIL_PARALLEL_Exception_hpp