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