toast/log/stream_policies.hpp

#ifndef toast_log_stream_policies_hpp_INCLUDED
#define toast_log_stream_policies_hpp_INCLUDED

namespace toast {
namespace log {
    
template <typename Policy>
struct StreamPolicyConcept
{
  void constraints() {
    std::basic_string<typename Policy::char_type> adjective;
    p.stream() << c << adjective << c << std::endl;
    p.stream().good();
    p.stream().eof();
    p.stream().fail();
    p.stream().bad();
    p.stream().rdstate();
    p.stream().clear();
  }
private:
  typename Policy::char_type c[10];
  Policy p;
};
    
template <typename CharT, typename Traits = std::char_traits<CharT> >
struct basic_any_stream
{
  typedef CharT char_type;
  typedef std::basic_ostream<CharT, Traits> stream_type;
  basic_any_stream() : os_(0) {}
  stream_type& stream()
  { 
    if(os_) return *os_;

    static bool do_once = true;
    if(do_once) {
      do_once = false;
      std::cerr << "any_stream::set_stream has not been called ignoring all"
                << "output\n";
    }
    return ignore();
  }
  void set_stream(stream_type *os) { os_ = os; }
protected:
  ~basic_any_stream() {}
private:
  stream_type *os_;
  stream_type & ignore()
  {
    static std::basic_ofstream<CharT, Traits> ignore_;
    return ignore_;
  }
};
    
typedef basic_any_stream<char> any_stream;

struct cout_stream
{
  typedef char char_type;
  std::ostream& stream() { return std::cout; }
protected:
  ~cout_stream() {}
};
    
struct cerr_stream
{
  typedef char char_type;
  std::ostream& stream() { return std::cerr; }
protected:
  ~cerr_stream() {}
};
    
struct clog_stream
{
  typedef char char_type;
  std::ostream& stream() { return std::clog; }
protected:
  ~clog_stream() {}
};
    
template <typename CharT, typename Traits = std::char_traits<CharT> >
struct basic_file_stream
{
  typedef CharT char_type;
  typedef std::basic_ostream<CharT, Traits> stream_type;
  stream_type& stream() 
  {
    return os_;
  }
  void open(std::string const &file)
  { 
    open(file.c_str()); 
  }
  void open(char const *file) 
  { 
    os_.open(file, std::ios::out|std::ios::app); 
  }
  void close() { os_.close(); }
protected:
  ~basic_file_stream() { close(); }
private:
  std::basic_ofstream<CharT, Traits> os_;
};

typedef basic_file_stream<char> file_stream;

}
}

#endif // toast_log_stream_policies_hpp_INCLUDED

---