MessageLogger.h

Go to the documentation of this file.

#ifndef _utl_MessageLogger_h_
#define _utl_MessageLogger_h_

#include <iomanip>
#include <iosfwd>
#include <iostream>


namespace utl {

  class MessageLogger {
  public:
    class Message {
      template<typename T>
      Message(MessageLogger& logger, const T& t, unsigned int l, bool e) :
        fLogger(logger),
        fMessageLevel(l),
        fTrailEOL(e)
      {
        // Set & backup.
        // See utl::MessageLogger::ApplyConfigurationOn.
        fPrevPrec = logger.ResolveStream().precision(logger.GetNPrecDigits());
        fPrevFlag = logger.ResolveStream().setf(std::ios::fixed, std::ios::floatfield);
        fLogger.Log(t, l);
      }
      friend class MessageLogger;
    public:
      template<typename T>
      Message&
      operator()(const T& t)
      {
        fLogger.Log(' ', fMessageLevel);
        fLogger.Log(t,   fMessageLevel);
        return *this;
      }
      ~Message()
      {
        if (fTrailEOL)
          fLogger.Log('\n', fMessageLevel);
        // ... and restore (see constructor).
        fLogger.ResolveStream().precision(fPrevPrec);
        fLogger.ResolveStream().setf(fPrevFlag);
      }
      // Yep, always false: meant to be used in termination conditions.
      explicit operator bool() const { return false; }
    private:
      MessageLogger& fLogger;
      unsigned int fMessageLevel;
      bool fTrailEOL;
      std::streamsize fPrevPrec;
      std::ios_base::fmtflags fPrevFlag;
    };

    MessageLogger(std::ostream& os, unsigned int l);
    template<typename T>
    Message operator()(const T& message, unsigned int level, bool trailEOL)
    { return Message(*this, message, level, trailEOL); }
    template<typename T>
    void
    Log(const T& message, unsigned int l)
    {
      if (l <= fLevel) {
        // Increase first...
        ++fFlushCounter;
        // perform the output...
        ResolveStream() << message;
        // and then check if flush has to be performed
        // (when zero, never flush).
        if (fFlushCounter == fFlushPeriod) {
          ResolveStream().flush();
          // Reset, note that as we increase first the counter and then
          // compare with the period we honor the criteria "no flush 
          // if period is zero).
          fFlushCounter = 0;
        }
      }
    }
    unsigned int GetLevel() const { return fLevel; }
    void SetLevel(unsigned int l) { fLevel = l; }
    unsigned int GetNPrecDigits() const { return fNPrecDigits; }
    void SetNPrecDigits(unsigned int n) { fNPrecDigits = n; }
    unsigned int GetFlushPeriod() const { return fFlushPeriod; }
    void SetFlushPeriod(unsigned int p) { fFlushPeriod = p; }
    template<class S>
    void
    ApplyConfigurationOn(S& stream)
      const
    {
      // See Message's constructor and detructor.
      //
      // This is done here with manipulators so as to be usable with 
      // streams like utl::TabularStream which doesn't have member functions to do this.
      stream << std::setprecision(fNPrecDigits) << std::fixed;
    }
  private:
    std::ostream&
    ResolveStream()
    {
      // Allow the given stream no to be opened...
      // is_open is strictly for ofstreams: use good that is included in ostream already.
      return fStream.good() ? fStream : std::cout;
    }
    std::ostream& fStream;
    unsigned int fLevel;
    // The type is an implementation-defined synonymn of one of the signed basic integral types (generally signed int or signed long)
    unsigned int fNPrecDigits;
    unsigned int fFlushCounter;
    unsigned int fFlushPeriod;
  };

}


#endif