RuntimeDoomed.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under 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_ENVIRONMENT_RUNTIMEDOOMED_HPP
#define STK_UTIL_ENVIRONMENT_RUNTIMEDOOMED_HPP

#include <sstream>

#include <stk_util/environment/RuntimeMessage.hpp>

namespace stk_classic {

typedef std::ostream &(*OStreamFunctionPtr)(std::ostream &);
typedef std::ios_base &(*IOSBaseFunctionPtr)(std::ios_base &);


unsigned get_doomed_count();

inline bool is_doomed() {
  return get_doomed_count() > 0;
}

void reset_doomed_count();

void set_max_doomed_count(unsigned int max_messages);

unsigned get_max_doomed_count();

void report_doomed(const char *message, const MessageCode &message_code = MessageCode::s_defaultMessageCode);

void report_symmetric_doomed(const char *message, const MessageCode &message_code = MessageCode::s_defaultMessageCode);

void report_deferred_doomed(const char *message, const char *aggregate, const MessageCode &message_code);

class RuntimeDoomedAdHoc
{
public:
  explicit RuntimeDoomedAdHoc(const MessageCode &message_code = MessageCode::s_defaultMessageCode);

  ~RuntimeDoomedAdHoc();

private:
  RuntimeDoomedAdHoc(const RuntimeDoomedAdHoc &);

  RuntimeDoomedAdHoc &operator=(const RuntimeDoomedAdHoc &);

public:
  RuntimeDoomedAdHoc &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }

  RuntimeDoomedAdHoc &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }

  template <class T>
  RuntimeDoomedAdHoc &operator<<(const T &t) {
    message << t;
    return *this;
  }

public:
  std::ostringstream    message;                

private:
  const MessageCode     m_messageCode;          
};


class RuntimeDoomedSymmetric
{
public:
  explicit RuntimeDoomedSymmetric(const MessageCode &message_code = MessageCode::s_defaultMessageCode);

  ~RuntimeDoomedSymmetric();

private:
  RuntimeDoomedSymmetric(const RuntimeDoomedSymmetric &);

  RuntimeDoomedSymmetric &operator=(const RuntimeDoomedSymmetric &);

public:
  RuntimeDoomedSymmetric &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }

  RuntimeDoomedSymmetric &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }

  template <class T>
  RuntimeDoomedSymmetric &operator<<(const T &t) {
    message << t;
    return *this;
  }

public:
  std::ostringstream    message;                

private:
  const MessageCode     m_messageCode;          
};


class RuntimeDoomedDeferred
{
public:
  explicit RuntimeDoomedDeferred(const MessageCode &message_code);

  ~RuntimeDoomedDeferred();

private:
  RuntimeDoomedDeferred(const RuntimeDoomedDeferred &);

  RuntimeDoomedDeferred &operator=(const RuntimeDoomedDeferred &);

public:
  RuntimeDoomedDeferred &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }

  RuntimeDoomedDeferred &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }

  template <class T>
  RuntimeDoomedDeferred &operator<<(const T &t) {
    message << t;
    return *this;
  }

public:
  std::ostringstream    message;                
  std::ostringstream    aggregate;              

private:
  const MessageCode     m_messageCode;          
};


} // namespace stk_classic

#endif // STK_UTIL_ENVIRONMENT_RUNTIMEDOOMED_HPP