RuntimeWarning.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_RUNTIMEWARNING_HPP
#define STK_UTIL_ENVIRONMENT_RUNTIMEWARNING_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_warning_count();
 
void reset_warning_count();
 
void set_max_warning_count(unsigned int max_messages);
 
unsigned get_max_warning_count();
 
void report_warning(const char *message, const MessageCode &message_code = MessageCode::s_defaultMessageCode);
 
void report_symmetric_warning(const char *message, const MessageCode &message_code = MessageCode::s_defaultMessageCode);
 
void report_deferred_warning(const char *message, const char *aggregate, const MessageCode &message_code);
 
class RuntimeWarningAdHoc
{
public:
  explicit RuntimeWarningAdHoc(MessageCode &message_code = MessageCode::s_defaultMessageCode);
 
  ~RuntimeWarningAdHoc();
 
private:
  RuntimeWarningAdHoc(const RuntimeWarningAdHoc &);
 
  RuntimeWarningAdHoc &operator=(const RuntimeWarningAdHoc &);
  
public:
  RuntimeWarningAdHoc &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }
 
  RuntimeWarningAdHoc &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }
 
  template <class T>
  RuntimeWarningAdHoc &operator<<(const T &t) {
    message << t;
    return *this;
  }
 
public:
  std::ostringstream    message;                
 
private:
  const MessageCode     m_messageCode;          
};
 
 
class RuntimeWarningSymmetric
{
public:
  explicit RuntimeWarningSymmetric(MessageCode &message_code = MessageCode::s_defaultMessageCode);
 
  ~RuntimeWarningSymmetric();
 
private:
  RuntimeWarningSymmetric(const RuntimeWarningSymmetric &);
 
  RuntimeWarningSymmetric &operator=(const RuntimeWarningSymmetric &);
  
public:
  RuntimeWarningSymmetric &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }
 
  RuntimeWarningSymmetric &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }
 
  template <class T>
  RuntimeWarningSymmetric &operator<<(const T &t) {
    message << t;
    return *this;
  }
 
public:
  std::ostringstream    message;                
 
private:
  const MessageCode     m_messageCode;          
};
 
 
class RuntimeWarningDeferred
{
public:
  explicit RuntimeWarningDeferred(const MessageCode &message_code);
 
  ~RuntimeWarningDeferred();
 
private:
  RuntimeWarningDeferred(const RuntimeWarningDeferred &);
 
  RuntimeWarningDeferred &operator=(const RuntimeWarningDeferred &);
 
public:
  RuntimeWarningDeferred &operator<<(OStreamFunctionPtr f) {
    f(message);
    return *this;
  }
 
  RuntimeWarningDeferred &operator<<(IOSBaseFunctionPtr f) {
    f(message);
    return *this;
  }
 
  template <class T>
  RuntimeWarningDeferred &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_RUNTIMEWARNING_HPP