toast/log_handle.hpp

Go to the documentation of this file.

#ifndef toast_log_log_handle_hpp_INCLUDED
#define toast_log_log_handle_hpp_INCLUDED

#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/ref.hpp>

#include <toast/log/severity.hpp>

namespace toast {

template <typename CharT>
class basic_log_handle
{
public:
  typedef CharT char_type;

  template <typename Logger>
  basic_log_handle(Logger &logger)
    : message_(boost::bind(&Logger::message_hook,
        boost::ref(logger), _1, _2)),
      forced_message_(boost::bind(&Logger::forced_message_hook,
          boost::ref(logger), _1, _2)),
      check_(boost::bind(&Logger::check, boost::ref(logger), _1)),
          consume_message_(boost::bind(&Logger::consume_message_hook,
                                                                   boost::ref(logger), _1, _2)),
          consume_forced_message_(boost::bind(&Logger::consume_forced_message_hook,
                                                                                  boost::ref(logger), _1, _2))
  {}
    
  basic_log_handle() {}
    
  basic_log_handle(basic_log_handle const &other)
    : message_(other.message_),
      forced_message_(other.forced_message_),
      check_(other.check_),
          consume_message_(other.consume_message_),
          consume_forced_message_(other.consume_forced_message_)
  {}

  basic_log_handle(basic_log_handle &other)
    : message_(other.message_),
      forced_message_(other.forced_message_),
      check_(other.check_),
          consume_message_(other.consume_message_),
          consume_forced_message_(other.consume_forced_message_)
  {}

  basic_log_handle& operator=(basic_log_handle temp)
  {
    swap(temp);
    return *this;
  }
    
  void swap(basic_log_handle &other)
  {
    message_.swap(other.message_);
    forced_message_.swap(other.forced_message_);
    check_.swap(other.check_);
        consume_message_.swap(other.consume_message_);
        consume_forced_message_.swap(other.consume_forced_message_);
  }
    
  template <typename Traits, typename Alloc>
  void message(std::basic_string<char_type, Traits, Alloc> const &m,
    log::severity s = log::DEFAULT) const {
    message(m.c_str(), s);
  }
  void message(char_type const *m, log::severity s = log::DEFAULT) const {
    if(message_) message_(m, s);
  }

  char_type* consume_message(char_type *m, log::severity s = log::DEFAULT) const {
        if(consume_message_) return consume_message_(m, s);
        return m;
  }

  char_type* consume_forced_message(char_type *m, log::severity s = log::DEFAULT) const {
        if(consume_forced_message_) return consume_forced_message_(m, s);
        return m;
  }
    
  template <typename Traits, typename Alloc>
  void forced_message(std::basic_string<char_type, Traits, Alloc> const &m,
    log::severity s = log::DEFAULT) const {
    forced_message(m.c_str(), s);
  }
  void forced_message(char_type const *m,
    log::severity s = log::DEFAULT) const {
    if(forced_message_) forced_message_(m, s);
  }
    
  bool check(log::severity s) const {
    if(check_) return check_(s);
    return false;
  }
    
private:
  boost::function<void (char_type const *, log::severity)> message_;
  boost::function<void (char_type const *, log::severity)> forced_message_;
  boost::function<bool (log::severity)> check_;
  boost::function<char_type* (char_type *, log::severity)> consume_message_;
  boost::function<char_type* (char_type *, log::severity)> consume_forced_message_;
};

typedef basic_log_handle<char> log_handle;

namespace log {

// this is so jamesp can just 'using namespace toast::log;'.
using ::toast::log_handle;

} // namespace log
} // namespace toast

#endif // toast_log_log_handle_hpp_INCLUDED

---