toast/logstream.hpp

#ifndef toast_logstream_hpp_INCLUDED
#define toast_logstream_hpp_INCLUDED

#include <toast/log.hpp>

#include <iostream>

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

#include <toast/config.hpp>

namespace toast {

namespace detail {
template <typename CharT, typename Traits, typename Alloc>
class proxy_logstream;
}

template <typename CharT, typename Traits = std::char_traits<CharT>,
          typename Alloc = std::allocator<CharT> >
class basic_logbuf : public std::basic_stringbuf<CharT, Traits, Alloc>
{
        static const int BUFFER_START_SIZE_ = 8; // 8 chosen only because it's stlport4 default
  typedef std::basic_stringbuf<CharT, Traits, Alloc> base_type;

  void init()
  {
          set_new_buffer(BUFFER_START_SIZE_);

          // By setting the next pointer to be non-null and equal to the end
          // pointer, we'll make basic_streambuf's implementation of sputc
          // think that overflow is going to occur, so that it will call our
          // implementation of overflow (which is virtual; sputc is not. We
          // need to insert a severity check, and this is the only way to
          // hook into sputc). Without this hook, an ostream reference to a
          // basic_logstream will, under some STL implementations (those
          // that don't implement sputc in terms of xsputn), cause a message
          // to be logged when its severity should prevent it.
          setp(reinterpret_cast<char_type*>(1), reinterpret_cast<char_type*>(1));
  }
        
public:
  typedef Alloc allocator_type;
  typedef CharT char_type;
  typedef Traits traits_type;
  typedef typename traits_type::int_type int_type;
  typedef typename traits_type::off_type off_type;
  typedef typename traits_type::pos_type pos_type;
  typedef basic_log_handle<CharT> log_handle_type;

  basic_logbuf(log::severity s = log::DEFAULT) : severity_(s)
  {
          init();
  }
        
  basic_logbuf(log_handle_type const &log, log::severity s = log::DEFAULT)
          : log_(log), severity_(s)
  {
          init();
  }

  virtual ~basic_logbuf()
  {
          delete[] real_pbase;
  }

  void log(log_handle_type const &log) { log_ = log; }
  log_handle_type log() const { return log_; }

  log::severity severity() const { return severity_; }
  void severity(log::severity s) { severity_ = s; }

  bool check(log::severity s) const { return log_.check(s); }

protected:      
  virtual int sync()
  {
        if(real_pbase != real_pptr) {
                real_sputc_with_overflow_check(traits_type::to_char_type('\0'));

                std::streamsize n = remaining_space();

                if(!log_.consume_forced_message(real_pbase, severity_)) {
                        // This is the consuming succesfull case.
                        // When consuming doesn't work, it gives back the pointer
                        // you asked it to consume. So when it returns NULL, it
                        // was *succesfull* at consuming it. Writing this here so
                        // I don't confuse myself again.
                        
                        // We manually set a new buffer so that the stream doesn't
                        // try to use the one we just passed ownership of to the log
                        set_new_buffer(n);
                }
                else {
                        // Consuming unsuccesfull case.
                        real_pptr = real_pbase;
                }
    }
    return 0;
  }

  virtual std::streamsize xsputn(char_type const *s, std::streamsize n)
  {
        // We have to have a check here, otherwise messages won't be severity
        // checked when chained in through an ostream reference
        if(!check(severity_))
                // We didn't actually write anything, but we have to lie. If we
                // return 0, then basic_stringbuf thinks that we can't do
                // anything about overflow and might as well shut off. So logging
                // stops working *completely*
                return n;
          
        grow_buffer_to_fit(n);

        std::copy(s, s + n, real_pptr);
        real_pptr += n;
        
        return n;
  }

  virtual int_type overflow(int_type meta = traits_type::eof())
  {
          // Because we cause all calls to sputc to actually call overflow,
          // overflow will get called even when overflow hasn't occurred.
          // The buffer will only actually grow if necessary.

          // Without this check, messages won't be checked when sputc'd through
          // an ostream reference (STLport4 does this when ostream::operator<<
          // is used on integers)
          if(!check(severity_))
                  return meta;

          return real_sputc_with_overflow_check(traits_type::to_char_type(meta));
  }

private:
  std::streamsize remaining_space()
  {
          return real_epptr - real_pptr;
  }

  int_type real_sputc_with_overflow_check(char_type ch)
  {
          grow_buffer_to_fit(1);

          return traits_type::not_eof(real_sputc(ch));
  }
        
  int_type real_sputc(char_type ch)
  {
          return traits_type::to_int_type(*(real_pptr++) = ch);
  }
        
  bool will_overflow(std::streamsize n_chars_to_write)
  {
          return (real_pptr + n_chars_to_write - 1) >= real_epptr;
  }

  void grow_buffer_to_fit(std::streamsize n)
  {
          if(!will_overflow(n))
                  return;

          char_type
                  *oldbuf_base = real_pbase,
                  *oldbuf_next = real_pptr,
                  *oldbuf_end = real_epptr;
          std::streamsize relative_loc = real_pptr - real_pbase;
          std::streamsize len = oldbuf_end - oldbuf_base;
          set_new_buffer(std::max(static_cast<std::streamsize>(len * 1.5), len + n));

          std::copy(oldbuf_base, oldbuf_end, real_pbase);
          real_pptr = real_pbase + relative_loc;

          delete[] oldbuf_base;
  }
        
  void set_new_buffer(std::streamsize n)
  {
          char_type* newbuf = new char_type[n];

          real_pbase = newbuf;
          real_pptr = newbuf;
          real_epptr = newbuf + n;
  }
        
#ifdef TOAST_NESTED_FRIEND_TEMPLATES

        template<typename T>
        friend detail::proxy_logstream<CharT, Traits, Alloc>& detail::proxy_logstream<CharT, Traits, Alloc>::operator<<(T const &toStream);

#else

public:

#endif

  char_type *real_pbase, *real_pptr, *real_epptr;
  log_handle_type log_;
  log::severity severity_;
};

template <typename CharT, typename Traits = std::char_traits<CharT>,
          typename Alloc = std::allocator<CharT> >
class basic_logstream : public std::basic_ostream<CharT, Traits>
{
  typedef std::basic_ostream<CharT, Traits> base_type;
public:
  typedef basic_logbuf<CharT, Traits, Alloc> streambuf_type;
  typedef typename streambuf_type::log_handle_type log_handle_type;

  basic_logstream(log::severity s = log::DEFAULT)
    : base_type(new streambuf_type(s)) {}

  basic_logstream(log_handle_type const &logger,
    log::severity s = log::DEFAULT)
    : base_type(new streambuf_type(logger, s))
  {}

  ~basic_logstream() { delete rdbuf(); }

  streambuf_type const* rdbuf() const
  {
    return static_cast<streambuf_type const *>(base_type::rdbuf());
  }

  streambuf_type* rdbuf()
  {
    return static_cast<streambuf_type *>(base_type::rdbuf());
  }
  
  void log(log_handle_type const &logger) 
  {
    base_type::flush();
    rdbuf()->log(logger);
  }

  log_handle_type log() const { return rdbuf()->log(); }

  log::severity severity() const { return rdbuf()->severity(); }

  void severity(log::severity s) 
  {
    base_type::flush();
    rdbuf()->severity(s);
  }

  bool check(log::severity s) const { return rdbuf()->check(s); }

};

namespace detail { 

// Emulates a basic_logstream. Used when chaining operator <<,
// prevents redundant severity checks.
template <typename CharT, typename Traits, typename Alloc>
class proxy_logstream
{
        typedef proxy_logstream<CharT, Traits, Alloc> this_t;
        typedef basic_logstream<CharT, Traits, Alloc> real_logstream_t;
        
public:
        proxy_logstream(real_logstream_t& stream, bool active) :
                _stream(stream), _active(active) {}

        operator real_logstream_t& () { return _stream; }

        proxy_logstream& operator <<(log::severity s)
        {
                _stream.severity(s);
                _active = _stream.check(s);
                return *this;
        }

        // Without this, << std::flush won't work, because std::flush is an overloaded function and the compiler
        // doesn't know which version to pass to the template operator<< below. Also we want things like flush
        // to go through unconditionally anyway.
        proxy_logstream& operator<<(std::basic_ostream<CharT, Traits>& (*pf)(std::basic_ostream<CharT, Traits>&))
        {
                pf(_stream);
                return *this;
        }

        template<typename T>
        proxy_logstream& operator<<(T const &toStream)
        {
                if(!_active)
                        return *this;

            static_cast<std::basic_ostream<CharT, Traits>&>(_stream) << toStream;
            return *this;
    }

private:
        real_logstream_t& _stream;
        bool _active;
};

}

template <typename CharT, typename Traits, typename Alloc>
detail::proxy_logstream<CharT, Traits, Alloc> operator <<(
  basic_logstream<CharT, Traits, Alloc> &os, log::severity s)
{
  os.severity(s);
  return detail::proxy_logstream<CharT, Traits, Alloc>(os, os.check(os.severity()));
}

template <typename CharT, typename Traits,
          typename Alloc, typename T >
detail::proxy_logstream<CharT, Traits, Alloc> operator<<(basic_logstream<CharT, Traits, Alloc>& stream, T const &toStream)
{
        if(stream.check(stream.severity())) {
                detail::proxy_logstream<CharT, Traits, Alloc> proxy(stream, true);
                proxy << toStream;

                return proxy;
        }
        
        return detail::proxy_logstream<CharT, Traits, Alloc>(stream, false);
}

typedef basic_logbuf<char> logbuf;

typedef basic_logstream<char> logstream;

namespace log {

using ::toast::logbuf;
using ::toast::logstream;

} // namespace log
} // namespace toast

#endif // toast_logstream_hpp_INCLUDED

---