toast/log.hpp

Go to the documentation of this file.

#ifndef toast_log_hpp_INCLUDED
#define toast_log_hpp_INCLUDED

#include <toast/concept_check.hpp>

#include <toast/log/verbosity_policies.hpp>
#include <toast/log/output_policies.hpp>
#include <toast/log/thread_policies.hpp>
#include <toast/log_handle.hpp>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>

namespace toast {

template <typename VerbosityPolicy,
          typename OutputPolicy,
          typename ThreadPolicy>
class logger;

namespace detail {

template<class logger_t, class Enable = void>
class consume_if_possible;

template<class logger_t>
class consume_if_possible<logger_t, typename boost::enable_if< boost::is_base_of<log::ConsumingOutputPolicy, logger_t> >::type >
{
public:
        static typename logger_t::char_type* do_it(logger_t& target,
                                                                                           typename logger_t::char_type *m,
                                                                                           log::severity severity)
        {
                static_cast<typename logger_t::output_policy&>(target).consume_message(m, severity);
                return NULL;
        }

private:
        consume_if_possible();
};

template<class logger_t>
class consume_if_possible<logger_t, typename boost::disable_if< boost::is_base_of<log::ConsumingOutputPolicy, logger_t> >::type >
{
public:
        static typename logger_t::char_type* do_it(logger_t& target,
                                                                                           typename logger_t::char_type* m,
                                                                                           log::severity severity)
        {
                static_cast<typename logger_t::output_policy&>(target).message(m, severity);
                return m;
        }

private:
        consume_if_possible();
};

}

template <typename VerbosityPolicy = log::check_verbosity,
          typename OutputPolicy = log::to_stderr_buffered<>,
          typename ThreadPolicy = log::neutral>
class logger
  : public VerbosityPolicy,
    public OutputPolicy,
    public ThreadPolicy
{
  TOAST_CLASS_REQUIRE(VerbosityPolicy, toast::log, VerbosityPolicyConcept);
  TOAST_CLASS_REQUIRE(OutputPolicy, toast::log, OutputPolicyConcept);
  TOAST_CLASS_REQUIRE(ThreadPolicy, toast::log, ThreadPolicyConcept);
    
public:
    
  typedef typename ThreadPolicy::scoped_lock scoped_lock;
    
  typedef typename OutputPolicy::char_type char_type;

  typedef OutputPolicy output_policy;

  typedef logger this_type;

  void message(char_type const *m, log::severity severity = log::DEFAULT) {
    message_hook(m, severity);
  }
        
  template <typename Traits, typename Alloc>
  void message(std::basic_string<char_type, Traits, Alloc> const &m,
    log::severity severity = log::DEFAULT) {
    message_hook(m.c_str(), severity);
  }
        
  void consume_message(char_type *m, 
                                           log::severity severity = log::DEFAULT) {
          consume_message_hook(m, severity);
  }
    
  void forced_message(char_type const *m,
    log::severity severity = log::DEFAULT) {
    forced_message_hook(m, severity);
  }

  void consume_forced_message(char_type const *m,
    log::severity severity = log::DEFAULT) {
    consume_forced_message_hook(m, severity);
  }

  template <typename Traits, typename Alloc>
  void forced_message(std::basic_string<char_type, Traits, Alloc> const &m,
    log::severity severity = log::DEFAULT) {
    forced_message_hook(m.c_str(), severity);
  }
private:
  void message_hook(char_type const *m, log::severity severity) {
    scoped_lock guard(*this);
    if(VerbosityPolicy::check(severity)) {
      OutputPolicy::message(m, severity);
    }
  }

  char_type* consume_message_hook(char_type *m, log::severity severity) {
    scoped_lock guard(*this);
    if(VerbosityPolicy::check(severity)) {
                return detail::consume_if_possible<this_type>::do_it(*this, m, severity);
    }

        return m;
  }
    
  void forced_message_hook(char_type const *m, log::severity severity) {
    scoped_lock guard(*this);
    OutputPolicy::message(m, severity);
  }

  char_type* consume_forced_message_hook(char_type *m, log::severity severity) {
    scoped_lock guard(*this);
        return detail::consume_if_possible<this_type>::do_it(*this, m, severity);
  }

    
  friend class basic_log_handle<char_type>;
};

namespace log {
// this is so jamesp can just 'using namespace toast::log;'.
using ::toast::logger;
}
} // namespace toast


#endif // toast_log_hpp_INCLUDED

---