toast/log/output_policies.hpp

Go to the documentation of this file.

#ifndef toast_log_output_policies_hpp_INCLUDED
#define toast_log_output_policies_hpp_INCLUDED

#include <iostream>
#include <fstream>
#include <toast/concept_check.hpp>

#include <cstdio>

#include <toast/log/header_policies.hpp>
#include <toast/log/footer_policies.hpp>
#include <toast/log/stream_policies.hpp>
#include <toast/log/rotation_policies.hpp>

namespace toast {
namespace log {
    
class ConsumingOutputPolicy {};

template <typename Policy>
struct OutputPolicyConcept
{
  void constraints() {
    p.message(c, ERROR);
  }
private:
  typename Policy::char_type c[10];
  Policy p;
};
    
typedef header_policy_aggregator<microseconds, severity_header> default_header_policy;
typedef rotation_policy<max_file_size, roll_rotation> default_rotation_policy;

template <typename HeaderPolicy = default_header_policy,
          typename FooterPolicy = newline,
          typename StreamPolicy = any_stream>
struct to_stream 
  : public HeaderPolicy,
    public FooterPolicy,
    public StreamPolicy
{
  TOAST_CLASS_REQUIRE(HeaderPolicy, toast::log, HeaderPolicyConcept);
  TOAST_CLASS_REQUIRE(FooterPolicy, toast::log, FooterPolicyConcept);
  TOAST_CLASS_REQUIRE(StreamPolicy, toast::log, StreamPolicyConcept);

  typedef typename StreamPolicy::char_type char_type;

  void message(char_type const *message, log::severity severity)
  { 
    StreamPolicy::stream() << HeaderPolicy::header(severity) << message
                           << FooterPolicy::footer(severity);
    StreamPolicy::stream().flush();
  }
protected:
  ~to_stream() {}
};
    
template <typename HeaderPolicy, typename StreamPolicy>
struct to_stream<HeaderPolicy, no_footer, StreamPolicy>
  : public HeaderPolicy,
    public no_footer,
    public StreamPolicy
{
  TOAST_CLASS_REQUIRE(HeaderPolicy, toast::log, HeaderPolicyConcept);
  TOAST_CLASS_REQUIRE(StreamPolicy, toast::log, StreamPolicyConcept);

  typedef typename StreamPolicy::char_type char_type;

  void message(char_type const *message, log::severity severity)
  {
    StreamPolicy::stream() << HeaderPolicy::header(severity) << message;
    StreamPolicy::stream().flush();
  }
protected:
  ~to_stream() {}
};
    
template <typename FooterPolicy, typename StreamPolicy>
struct to_stream<no_header, FooterPolicy, StreamPolicy>
  : public no_header,
    public FooterPolicy,
    public StreamPolicy
{
  TOAST_CLASS_REQUIRE(FooterPolicy, toast::log, FooterPolicyConcept);
  TOAST_CLASS_REQUIRE(StreamPolicy, toast::log, StreamPolicyConcept);

  typedef typename StreamPolicy::char_type char_type;

  void message(char_type const *message, log::severity severity)
  {
    StreamPolicy::stream() << message << FooterPolicy::footer(severity);
    StreamPolicy::stream().flush();
  }
protected:
  ~to_stream() {}
};
    
template <typename StreamPolicy>
struct to_stream<no_header, no_footer, StreamPolicy>
  : public no_header,
    public no_footer,
    public StreamPolicy
{
  TOAST_CLASS_REQUIRE(StreamPolicy, toast::log, StreamPolicyConcept);

  typedef typename StreamPolicy::char_type char_type;

  void message(char_type const *message, log::severity severity)
  {
    StreamPolicy::stream() << message;
    StreamPolicy::stream().flush();
  }
protected:
  ~to_stream() {}
};
    
/* The following stream policies are effectively template typedefs, and if
   C++ ever supports template typedefs should be replaced as such.
*/
    
template <typename HeaderPolicy = default_header_policy,
          typename FooterPolicy = newline>
struct to_stderr_buffered
  : public to_stream<HeaderPolicy, FooterPolicy, clog_stream>
{
  typedef typename 
  to_stream<HeaderPolicy, FooterPolicy, clog_stream>::char_type char_type;
protected:
  ~to_stderr_buffered() {}
};
    
template <typename HeaderPolicy = default_header_policy,
  typename FooterPolicy = newline,
  typename RotationPolicy = default_rotation_policy>
struct to_file : 
  public HeaderPolicy,
  public FooterPolicy,
  public RotationPolicy
{
  TOAST_CLASS_REQUIRE(RotationPolicy, toast::log, RotationPolicyConcept);
  typedef char char_type;

  void message(char_type const *message, log::severity severity)
  { 
    int written = 0;
    std::string header_normalized(HeaderPolicy::header(severity));
    std::string footer_normalized(FooterPolicy::footer(severity));
    written += std::fprintf(f_, header_normalized.c_str());
    written += std::fprintf(f_, message);
    written += std::fprintf(f_, footer_normalized.c_str());

    std::fflush(f_);
    if (RotationPolicy::test(written)) rotate();
  }

  void open(std::string const& file)
  {
    open(file.c_str());
  }
  void open(char const* file)
  {
    RotationPolicy::set_file(file);
    f_ = std::fopen(file, "a");

        if(!f_)
                throw std::ios_base::failure("Unable to open log file. Check file permissions.");
  }
  void close()
  {
        if(f_) std::fclose(f_);
  }
  void rotate()
  {
    close();
    f_ = std::fopen(RotationPolicy::rotate(), "a");
  }

protected:
  ~to_file() { close(); }
private:
  FILE* f_;
};
    
template <typename HeaderPolicy = default_header_policy,
          typename FooterPolicy = newline>
struct to_stdout
  : public to_stream<HeaderPolicy, FooterPolicy, cout_stream>
{
  typedef typename 
  to_stream<HeaderPolicy, FooterPolicy, cout_stream>::char_type char_type;
protected:
  ~to_stdout() {}
};
    
template <typename HeaderPolicy = default_header_policy,
          typename FooterPolicy = newline>
struct to_stderr
  : public to_stream<HeaderPolicy, FooterPolicy, cerr_stream>
{
  typedef typename 
  to_stream<HeaderPolicy, FooterPolicy, cerr_stream>::char_type char_type;
protected:
  ~to_stderr() {}
};
    
template <typename FirstOutputPolicy, typename SecondOutputPolicy>
struct output_policy_aggregator
  : public FirstOutputPolicy, public SecondOutputPolicy
{
  TOAST_CLASS_REQUIRE(FirstOutputPolicy, toast::log, OutputPolicyConcept);
  TOAST_CLASS_REQUIRE(SecondOutputPolicy, toast::log, OutputPolicyConcept);

  typedef typename FirstOutputPolicy::char_type char_type;

  void message(char_type const *message, log::severity severity)
  {
    FirstOutputPolicy::message(message, severity);
    SecondOutputPolicy::message(message, severity);
  }
protected:
  ~output_policy_aggregator() {}
};

/*
  other possibilities, but not in toast:
      
  to_syslog
  to_ErrorHandler
  to_database?
*/

}
}

#endif // toast_log_output_policies_hpp_INCLUDED

---