LogControl.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_LOGCONTROL_HPP
#define STK_UTIL_ENVIRONMENT_LOGCONTROL_HPP
 
#include <ostream>
#include <sstream>
#include <string>
#include <map>
 
#include <stk_util/util/string_case_compare.hpp>
 
namespace stk_classic {
 
struct LogControlRule
{
  virtual ~LogControlRule()
  {}
  
  virtual LogControlRule *clone() const = 0;
  
  virtual bool next() = 0;
};
 
 
struct LogControlRuleAlways : public LogControlRule
{
  virtual ~LogControlRuleAlways()
  {}
  
  LogControlRuleAlways()
  {}
 
  virtual LogControlRule *clone() const {
    return new LogControlRuleAlways(*this);
  }
 
  virtual bool next() {
    return true;
  }
};
 
 
struct LogControlRuleInterval : public LogControlRule
{
  LogControlRuleInterval(int interval);
 
  virtual ~LogControlRuleInterval()
  {}
  
  virtual LogControlRule *clone() const {
    return new LogControlRuleInterval(*this);
  }
 
  virtual bool next();
  
private:
  int           m_interval;
  int           m_count;
};
 
 
class RuleMap
{
public:
  typedef std::map<std::string, LogControlRule *, LessCase> Map;
 
  RuleMap()
    : m_ruleMap()
  {}
 
  ~RuleMap() {
    for (Map::iterator it = m_ruleMap.begin(); it != m_ruleMap.end(); ++it)
      delete (*it).second;
  }
  
  void addLogControlRule(const std::string &rule_name, const LogControlRule &rule) {
    Map::iterator it = m_ruleMap.find(rule_name);
    if (it != m_ruleMap.end())
      m_ruleMap.erase(it);
    
    m_ruleMap[rule_name] = rule.clone();
  }
 
  LogControlRule *getLogControlRule(const std::string &rule_name) {
    Map::iterator it = m_ruleMap.find(rule_name);
 
    if (it != m_ruleMap.end())
      return (*it).second;
 
    else {
      std::pair<Map::iterator, bool> result = m_ruleMap.insert(Map::value_type(rule_name, new LogControlRuleAlways));
      return (*result.first).second;
    }
  }
 
private:
  Map           m_ruleMap;
};
 
 
enum State {
  ON,           
  CACHE         
};
 
class LogControl
{
public:
  LogControl(std::ostream &log_stream, const LogControlRule &rule);
 
  LogControl(std::ostream &log_stream,const std::string &rule_name);
  
  ~LogControl();
 
  void next();
 
  void fail();
 
private:
  LogControl *          m_parent;               
  LogControlRule *      m_rule;                 
 
  State                 m_state;                
 
  std::ostream &        m_logStream;            
  std::streambuf *      m_logStreambuf;         
  std::ostringstream    m_cacheStream;          
 
  // Do not implement...
  LogControl(const LogControl&);
  LogControl & operator = (const LogControl&);
};
 
} // namespace stk_classic
 
#endif //  STK_UTIL_ENVIRONMENT_LOGCONTROL_HPP