Logger.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef LOGGER_H
#define LOGGER_H

#include <limits.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>

#include <coil/Mutex.h>
#include <coil/Guard.h>

#ifndef LINE_MAX
#define LINE_MAX  1024
#endif

#define BUFFER_LEN LINE_MAX

namespace coil
{
  template <typename _CharT, typename _Traits=std::char_traits<_CharT> >
  class log_streambuf
    : public ::std::basic_streambuf<_CharT, _Traits>
  {
  public:
    typedef _CharT                                       char_type;
    typedef _Traits                                      traits_type;
    typedef std::basic_streambuf<char_type, traits_type> streambuf_type;
    typedef coil::Mutex Mutex;
    typedef coil::Guard<coil::Mutex> Guard;

    log_streambuf()
      : streambuf_type()
    {
      char *pStart = m_buf;
      char *pEnd = m_buf + (BUFFER_LEN - 1);
      this->setp(pStart, pEnd);
      this->setg(pStart, pStart, pEnd);
    }

    virtual ~log_streambuf()
    {
    }

    void addStream(streambuf_type* stream, bool cleanup = false)
    {
      m_streams.push_back(Stream(stream, cleanup));
    }

    bool removeStream(streambuf_type* stream)
    {
      std::vector<coil::log_streambuf<char>::Stream>::iterator it;
      for( it = m_streams.begin(); it != m_streams.end(); it++ )
      {
          if (it->stream_ == stream)
            {
              m_streams.erase(it);
              return true;
            }
      }
      return false;
    }

    std::vector<streambuf_type*> getBuffers()
    {
      std::vector<streambuf_type*> buffs;
      for (int i(0), len(m_streams.size()); i < len; ++i)
        {
          buffs.push_back(m_streams[i].stream_);
        }
      return buffs;
    }
   
  protected:
    virtual std::streamsize xsputn(const char_type* s, std::streamsize n)
    {
      stream_sputn();
      for (size_t i(0), len(m_streams.size()); i < len; ++i)
        {
          Guard gaurd(m_streams[i].mutex_);
          m_streams[i].stream_->sputn(s, n);
        }
      return n;
    }

    virtual std::streamsize stream_sputn()
    {
      size_t bytes_to_write;
      bytes_to_write = this->pptr() - this->gptr();
      if (bytes_to_write > 0)
        {
          for (size_t i(0), len(m_streams.size()); i < len; ++i)
            {
              Guard gaurd(m_streams[i].mutex_);
              m_streams[i].stream_->sputn(this->gptr(), bytes_to_write);
            }
          this->gbump(static_cast<int>(bytes_to_write));
          if (this->gptr() >= this->pptr())
            {
              this->pbump(static_cast<int>(this->pbase() - this->pptr()));
              this->gbump(static_cast<int>(this->pbase() - this->gptr()));
            }
        }
      return bytes_to_write;
    }

    virtual std::streamsize stream_sputn(const char_type* s, std::streamsize n)
    {
      
      for (size_t i(0), len(m_streams.size()); i < len; ++i)
        {
          Guard gaurd(m_streams[i].mutex_);
          m_streams[i].stream_->sputn(s, n);
          m_streams[i].stream_->pubsync();
        }
      return n;
    }
    virtual int overflow (int c = traits_type::eof())
    {
      Guard guard(m_mutex);
//      if (traits_type::eq_int_type(c, traits_type::eof()))
//        return c;
//
//      char_type last_char = traits_type::to_char_type(c);
//      if (sputn(&last_char, 1) != 1)
//        return traits_type::eof();
//      else
//        return c;

      if (this->pbase())
        {
          if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
            return traits_type::eof();
          // Add extra character to buffer if not EOF
          if (!traits_type::eq_int_type(c, traits_type::eof()))
            {
              this->pbump(-1);
              *(this->pptr()) = traits_type::to_char_type(c);
              this->pbump(1);
            }
          // Number of characters to write to file
          size_t bytes_to_write = this->pptr() - this->gptr();
          // Overflow doesn't fail if nothing is to be written
          if (bytes_to_write > 0)
            {
              if (stream_sputn(this->gptr(), bytes_to_write) != bytes_to_write)
                return traits_type::eof();
              // Reset next pointer to point to pbase on success
              this->pbump(static_cast<int>(this->pbase() - this->pptr()));
              this->gbump(static_cast<int>(this->pbase() - this->gptr()));
            }
        }
      // Write extra character to file if not EOF
      else if (!traits_type::eq_int_type(c, traits_type::eof()))
        {
          // Impromptu char buffer (allows "unbuffered" output)
          char_type last_char = traits_type::to_char_type(c);
          // If gzipped file won't accept this character, fail
          if (stream_sputn(&last_char, 1) != 1)
            return traits_type::eof();
        }
      // If you got here, you have succeeded (even if c was EOF)
      // The return value should therefore be non-EOF
      if (traits_type::eq_int_type(c, traits_type::eof()))
        return traits_type::not_eof(c);
      else
        return c;
    } 

    virtual int sync()
    {
      if (this->pbase())
        {
          Guard guard(m_mutex);
          if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
            return -1;

          size_t bytes_to_write;
          bytes_to_write = this->pptr() - this->gptr();
          if (bytes_to_write > 0)
            {
              if (stream_sputn(this->gptr(), bytes_to_write) != bytes_to_write)
                {
                  return -1;
                }
              this->gbump(static_cast<int>(bytes_to_write));
              if (this->gptr() >= this->pptr())
                {
                  this->pbump(static_cast<int>(this->pbase() - this->pptr()));
                  this->gbump(static_cast<int>(this->pbase() - this->gptr()));
                }
            }
        }
      else
        {
          this->overflow();
        }
      return 0;
    }

  public:

    struct Stream
    {
      Stream(streambuf_type* stream, bool cleanup = false)
        : stream_(stream), cleanup_(cleanup)
      {
      }

      virtual ~Stream()
      {
      }

      Stream(const Stream& x)
        : stream_(x.stream_)
      {
      }

      Stream& operator=(const Stream& x)
      {
        Stream tmp(x);
        tmp.swap(*this);
        return *this;
      }

      void swap(Stream& x)
      {
        streambuf_type* stream = x.stream_;
        bool cleanup = x.cleanup_;

        x.stream_ = this->stream_;
        x.cleanup_ = this->cleanup_; 

        this->stream_ = stream;
        this->cleanup_ = cleanup;
      }
      mutable Mutex mutex_;
      streambuf_type* stream_;
      bool cleanup_;
    };

  private:

    log_streambuf(const log_streambuf& x);

    log_streambuf& operator=(const log_streambuf& x);

    std::vector<Stream> m_streams;
    Mutex m_mutex;
    char m_buf[BUFFER_LEN];
  };


  template <typename _CharT, typename _Traits=std::char_traits<_CharT> >
  class log_stream
    : public std::basic_ostream<_CharT, _Traits>
  {
  public:
    // Types:
    typedef _CharT                                       char_type;
    typedef _Traits                                      traits_type;
    typedef std::basic_ostream<char_type, traits_type>   ostream_type;
    typedef std::basic_streambuf<char_type, traits_type> streambuf_type;
    typedef coil::Mutex Mutex;
    typedef coil::Guard<Mutex> Guard;

    log_stream(streambuf_type* sb, int levelmin, int levelmax, int level)
      : ostream_type(sb),
        m_minLevel(levelmin), m_maxLevel(levelmax), m_logLevel(level)
    {
      if (m_minLevel >= m_maxLevel) throw std::bad_alloc();
      this->init(sb);
    }

    virtual void header(int level)
    {
      return;
    }

    bool setLevel(int level)
    {
      if (m_minLevel <= level && level <= m_maxLevel)
        {
          m_logLevel = level;
          return true;
        }
      return false;
    }

    int getLevel() const
    {
      return m_logLevel;
    }
    
    void enableLock()
    {
      m_lockEnable = true;
    }
    
    void disableLock()
    {
      m_lockEnable = false;
    }
    
    ostream_type& level(int level)
    {
      if (m_minLevel <= level && level <= m_logLevel)
    {
          header(level);
      return *this;
    }
      else
    {
      return m_dummy;
    }
    }
    
    inline bool isValid(int level) const
    {
      return m_minLevel <= level && level <= m_logLevel;
    }

    inline void lock()
    {
      if (m_lockEnable) m_mutex.lock();
    }
    
    inline void unlock()
    {
      if (m_lockEnable) m_mutex.unlock();
    }

    
  protected:

    ~log_stream(){};

    log_stream();

    log_stream(const log_stream& x);

    log_stream& operator=(const log_stream& x);

  private:
    int m_minLevel, m_maxLevel;
    int m_logLevel;

    std::ofstream m_dummy;
  public:

    static bool m_lockEnable;

    static Mutex m_mutex;
  };

  template <typename _CharT, typename _Traits >
  bool log_stream<_CharT,_Traits >::m_lockEnable = true;

  template <typename _CharT, typename _Traits >
  coil::Mutex log_stream<_CharT,_Traits>::m_mutex("Mutex for Logger.");

  typedef log_streambuf<char> LogStreamBuffer;
  typedef log_stream<char> LogStream;

};
#endif // LOGGER_H