Writer.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010, 2011 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/
 
#ifndef STK_UTIL_DIAG_WRITER_HPP
#define STK_UTIL_DIAG_WRITER_HPP
 
#include <ostream>
#include <string>
#include <vector>
#include <utility>
#include <stdint.h>
 
#include <stk_util/diag/Writer_fwd.hpp>
 
namespace stk_classic {
namespace diag {
 
 
class WriterThrowSafe
{
public:
  explicit WriterThrowSafe(Writer &writer);
 
  ~WriterThrowSafe();
 
private:
  Writer &      m_writer;
  int           m_depth;
 
  WriterThrowSafe(const WriterThrowSafe &);
  void operator = (const WriterThrowSafe &);
};
 
 
class Writer
{
public:
  enum Flags {
    DISABLED    =  0x00,
    ENABLED    =  0x01
  };
 
private:
  struct LineMaskStack : public std::vector<std::pair<int, PrintMask> >
  {
    LineMaskStack() {
      push_back(std::pair<int, PrintMask>(0, LOG_ALWAYS));
    }
 
    LineMaskStack &pushDepth() {
      push_back(std::make_pair(back().first + 1, back().second));
      return *this;
    }
 
    LineMaskStack &push(PrintMask line_mask) {
      push_back(std::make_pair(back().first, line_mask));
      return *this;
    }
 
    LineMaskStack &pop() {
      if (size() > 1)
        pop_back();
      return *this;
    }
 
    LineMaskStack &popLineMask() {
      if (size() > 1 && getNextDepth() == getDepth())
        pop_back();
      return *this;
    }
 
    int getDepth() const {
      return back().first;
    }
 
    int getLineMask() const {
      return back().second;
    }
 
    int getNextDepth() const {
      return (end() - 2)->first;
    }
 
    LineMaskStack &resetDepth() {
      while (size() > 1 && getNextDepth() == getDepth())
        pop_back();
      return *this;
    }
  };
 
public:
  explicit Writer(std::streambuf *streambuf, PrintMask print_mask = static_cast<PrintMask>(LOG_MEMBERS), Flags flags = static_cast<Flags>(ENABLED));
 
  ~Writer();
 
  std::ostream &getStream() {
    return m_writerStream;
  }
 
  Writer &setFlags(int flags) {
    m_flags = (Flags) flags;
    return *this;
  }
 
  int getFlags() {
    return m_flags;
  }
 
  int getDepth() const {
    return m_lineMaskStack.getDepth();
  }
 
  Writer &restoreDepth(int depth) {
    while (m_lineMaskStack.getDepth() > depth)
      pop();
    return *this;
  }
 
  Writer &setPrintMask(PrintMask mask = 0) {
    m_printMask = mask;
    return *this;
  }
 
  //Writer &setPrintMask(const char *mask_string);
 
  Writer &setLineMask(PrintMask line_mask) {
    m_lineMaskStack.push(line_mask);
 
    return *this;
  }
 
  Writer &m(PrintMask line_mask) {
    setLineMask(line_mask);
 
    return *this;
  }
 
  Writer &w(bool on, PrintMask line_mask) {
    setLineMask(on ? line_mask : 0x80000000);
 
    return *this;
  }
 
  Writer &t(PrintMask line_mask = 0) {
    setLineMask(line_mask | stk_classic::LOG_TRACE);
 
    return *this;
  }
 
  PrintMask getPrintMask() {
    return m_printMask;
  }
 
  bool isEnabled() {
    return (m_flags & ENABLED) != 0;
  }
 
  bool isLoggable(PrintMask line_mask) {
    return line_mask == 0            // Always
      || ((line_mask & m_printMask & stk_classic::LOG_TRACE)      // LOG_TRACE?
          ? isTracing()              // Yes, must be tracing
//    : (line_mask & m_printMask) != 0);        // No, any matching bits
          : (line_mask & m_printMask) == line_mask);      // No, all matching bits
  }
 
  bool shouldPrint() {
    return shouldPrint(m_lineMaskStack.getLineMask());
  }
 
  bool shouldPrint(PrintMask line_mask) {
    return isEnabled() && isLoggable(line_mask);
  }
 
  bool shouldTrace(int line_mask) {
    return line_mask == 0            // Always
      || (line_mask & m_printMask) != 0;        // Any set
//      || (line_mask & m_printMask) == line_mask;      // All set
  }
 
  Writer &dflush();
 
  Writer &dendl();
 
  Writer &push();
 
  Writer &pop();
 
  Writer &resetLineMask();
 
#ifndef SWIG
 
  Writer& operator<<(Writer& (*f)(Writer&));
 
  Writer& operator<<(std::ios_base& (*f)(std::ios_base&));
 
  Writer& operator<<(std::ostream& (*f)(std::ostream&));
#endif // SWIG
 
  int incTraceDepth() {
    return ++m_traceDepth;
  }
 
  int decTraceDepth() {
    return --m_traceDepth;
  }
 
  bool isTracing() {
    return m_traceDepth <= 0 ? false
      : (m_traceDepth == 1 || (m_traceDepth > 1 && (m_printMask & stk_classic::LOG_TRACE_SUB_CALLS)));
  }
 
  bool isTraceable() {
    return isTracing() || (m_printMask & stk_classic::LOG_TRACE) != 0; // Currently in a trace or tracing bit set
  }
 
private:
  Flags        m_flags;    
  PrintMask      m_printMask;    
  LineMaskStack      m_lineMaskStack;  
  int        m_traceDepth;    
  std::ostream                  m_writerStream;
};
 
inline Writer &dendl(Writer &dout) {
  return dout.dendl();
}
 
inline Writer &dflush(Writer &dout) {
  return dout.dflush();
}
 
inline Writer &push(Writer &dout) {
  return dout.push();
}
 
inline Writer &pop(Writer &dout) {
  return dout.pop();
}
 
 
struct _setlinemask
{
  _setlinemask(PrintMask line_mask)
    : m_lineMask(line_mask)
  {}
 
  PrintMask    m_lineMask;
};
 
inline _setlinemask setlinemask(PrintMask line_mask) {
  return _setlinemask(line_mask);
}
 
#ifndef SWIG
inline Writer &operator<<(Writer &dout, _setlinemask set_line_mask) {
  return dout.setLineMask(set_line_mask.m_lineMask);
}
#endif // SWIG
 
inline Writer &resetlinemask(Writer &dout) {
  return dout.resetLineMask();
}
 
#ifndef SWIG
Writer &operator<<(Writer &dout, const char *c_str);
Writer &operator<<(Writer &dout, const std::string &str);
Writer &operator<<(Writer &dout, const void *ptr);
Writer &operator<<(Writer &dout, const float &x);
Writer &operator<<(Writer &dout, const double &x);
Writer &operator<<(Writer &dout, const long double &x);
Writer &operator<<(Writer &dout, const int &x);
Writer &operator<<(Writer &dout, const unsigned int &x);
Writer &operator<<(Writer &dout, const long &x);
Writer &operator<<(Writer &dout, const unsigned long &x);
Writer &operator<<(Writer &dout, const short &x);
Writer &operator<<(Writer &dout, const unsigned short &x);
Writer &operator<<(Writer &dout, const long long &x);
Writer &operator<<(Writer &dout, const unsigned long long &x);
#endif // SWIG
 
template <class T>
class c_ptr_
{
public:
  explicit c_ptr_(const T *t)
    : m_t(t)
  {}
 
public:
  const T *  m_t;      
};
 
template <class T>
c_ptr_<T> c_ptr(const T *t) {
  return c_ptr_<T>(t);
}
 
template <class T, typename R>
class c_ptr_func_
{
public:
#ifndef SWIG
  explicit c_ptr_func_(const T *t, R (T::*pmf)() const)
    : m_t(t),
      m_pmf(pmf)
  {}
public:
  const T *  m_t;      
  R (T::*m_pmf)() const;    
#endif // SWIG
};
 
#ifndef SWIG
template <class T, typename R>
c_ptr_func_<T, R> c_ptr_func(const T *t, R (T::*pmf)() const) {
  return c_ptr_func_<T, R>(t, pmf);
}
 
template <class T>
Writer &operator<<(Writer &dout, const c_ptr_<T> &c) {
  dout << "(pointer " << (void *) c.m_t << "), ";
 
  if (c.m_t)
    dout << *c.m_t;
  else
    dout << "<not created>";
 
  return dout;
}
 
template <class T, typename R>
Writer &operator<<(Writer &dout, const c_ptr_func_<T, R> &c) {
  if (c.m_t)
    dout << "(pointer), " << (c.m_t->*c.m_pmf)();
  else
    dout << "(pointer), <not created>";
 
  return dout;
}
#endif // SWIG
 
 
} // namespace diag
} // namespace stk_classic
 
#include <stk_util/diag/WriterManip.hpp>
 
namespace sierra {
 
 
using stk_classic::diag::push;
using stk_classic::diag::pop;
using stk_classic::diag::dendl;
using stk_classic::diag::dflush;
 
namespace Diag {
 
using stk_classic::diag::push;
using stk_classic::diag::pop;
using stk_classic::diag::dendl;
using stk_classic::diag::dflush;
using stk_classic::diag::setlinemask;
using stk_classic::diag::resetlinemask;
using stk_classic::diag::c_ptr;
using stk_classic::diag::c_ptr_func;
using stk_classic::diag::c_ptr_func_;
 
}
 
} // namespace sierra
 
#include <stk_util/diag/WriterExt.hpp>
 
#endif // STK_UTIL_DIAG_WRITER_HPP