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