Writer.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 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 {
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 &t(PrintMask line_mask = 0) {
    setLineMask(line_mask | stk::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::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();

  Writer& operator<<(Writer& (*f)(Writer&));

  Writer& operator<<(std::ios_base& (*f)(std::ios_base&));

  Writer& operator<<(std::ostream& (*f)(std::ostream&));

  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::LOG_TRACE_SUB_CALLS)));
  }

  bool isTraceable() {
    return isTracing() || (m_printMask & stk::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);
}

inline Writer &operator<<(Writer &dout, _setlinemask set_line_mask) {
  return dout.setLineMask(set_line_mask.m_lineMask);
}

inline Writer &resetlinemask(Writer &dout) {
  return dout.resetLineMask();
}

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);
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:
  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;    
};

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;
}


} // namespace diag
} // namespace stk

#endif // STK_UTIL_DIAG_WRITER_HPP