IndentStreambuf.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_UTIL_INDENTSTREAMBUF_HPP
#define STK_UTIL_UTIL_INDENTSTREAMBUF_HPP
 
#include <streambuf>
#include <utility>
 
namespace stk_classic {
 
static const char PUSH = '\016';                                
static const char POP = '\017';                                 
static const char LEFT = '\021';                                
 
template<class Ch, class Tr = std::char_traits<Ch> >
class basic_indent_streambuf : public std::basic_streambuf<Ch, Tr>
{
public:
  enum {
    MAX_INDENT_LEVEL = 50                                       
  };
 
  enum Flags {
    NO_BRACES      = 0x00,                                      
    NO_BLANK_LINES = 0x00,                                      
    BRACES         = 0x01,                                      
    BLANK_LINES    = 0x02                                       
  };
 
  explicit basic_indent_streambuf(std::basic_streambuf<Ch, Tr> *stream_buffer, size_t indent_size = 2, unsigned flags = BRACES)
    : m_streamBuffer(stream_buffer),
      m_atLineBegin(true),
      m_leftJustify(false),
      m_indentLevel(0),
      m_nextIndentLevel(0),
      m_indentSize(indent_size),
      m_flags((Flags) flags),
      m_indentString(0)
  {
    set_indent_size(indent_size);
  }
 
  virtual ~basic_indent_streambuf() {
    delete[] m_indentString;
  }
 
  void redirect(std::basic_streambuf<Ch, Tr> *stream_buffer) {
    m_streamBuffer = stream_buffer;
  }
 
  std::streambuf *get_stream_buffer() {
    return m_streamBuffer;
  }
  
  void set_indent_size(size_t indent_size) {
    m_indentSize = indent_size;
 
    delete[] m_indentString;
    m_indentString = new Ch[MAX_INDENT_LEVEL*m_indentSize];
    std::fill(m_indentString, m_indentString + MAX_INDENT_LEVEL*m_indentSize, static_cast<Ch>(' '));
  }
 
  void set_flags(unsigned flags) {
    m_flags = (Flags) flags;
  }
 
 
private:
  size_t indent_level() {
    return std::min(m_indentLevel*m_indentSize, (size_t) MAX_INDENT_LEVEL*m_indentSize);
  }
 
  void prefix() {
    if (m_atLineBegin) {
      if (!m_leftJustify)
        m_streamBuffer->sputn(m_indentString, indent_level());
      m_leftJustify = false;
      m_atLineBegin = false;
    }
  }
 
  void next_line() {
    if (m_nextIndentLevel > m_indentLevel) {
      if (m_flags & BRACES) 
  m_streamBuffer->sputn(" {", 2);
      m_streamBuffer->sputc(Tr::to_int_type('\n'));
    }
    else if (m_nextIndentLevel < m_indentLevel) {
      m_indentLevel = m_nextIndentLevel;
      if (!m_atLineBegin)
        m_streamBuffer->sputc(Tr::to_int_type('\n'));
      if (m_flags & BRACES) {
        m_streamBuffer->sputn(m_indentString, indent_level());
        m_streamBuffer->sputc(Tr::to_int_type('}'));
        m_streamBuffer->sputc(Tr::to_int_type('\n'));
      }
    }
    else if (!m_atLineBegin || (m_flags & BLANK_LINES))
      m_streamBuffer->sputc(Tr::to_int_type('\n'));
 
    m_indentLevel = m_nextIndentLevel;
    m_atLineBegin = true;
  }
 
public:
  virtual typename std::basic_streambuf<Ch, Tr>::int_type overflow(typename std::basic_streambuf<Ch, Tr>::int_type c) {
    if (c == Tr::to_int_type('\n'))
      next_line();
    else if (c == Tr::to_int_type(POP)) {
      if (m_nextIndentLevel != m_indentLevel)
  next_line();
      if (m_indentLevel > 0)
  m_nextIndentLevel = m_indentLevel - 1;
    }
    else if (c == Tr::to_int_type(PUSH)) {
      if (m_nextIndentLevel != m_indentLevel)
  next_line();
      m_nextIndentLevel = m_indentLevel + 1;
    }
    else if (c == Tr::to_int_type(LEFT)) {
      m_leftJustify = true;
    }
    else {
      prefix();
      m_streamBuffer->sputc(c);
    }
 
    return c;
  }
 
  virtual std::streamsize xsputn(const Ch *p,  std::streamsize n) {
    const Ch *p_end = p + n;
    for (const Ch *q = p; q != p_end; ++q) {
 
// If at start of line, PUSH and POP have immediate effect
      if (p == q && m_atLineBegin) {
  if (Tr::to_int_type(*p) == Tr::to_int_type('\n')) {
    next_line();
    ++p;
  }
  else if (Tr::to_int_type(*p) == Tr::to_int_type(POP)) {
    ++p;
    if (m_nextIndentLevel != m_indentLevel)
      next_line();
    if (m_indentLevel > 0)
      m_nextIndentLevel = m_indentLevel - 1;
  }
  else if (Tr::to_int_type(*p) == Tr::to_int_type(PUSH)) {
    ++p;
    if (m_nextIndentLevel != m_indentLevel)
      next_line();
    m_nextIndentLevel = m_indentLevel + 1;
  }
        else if (Tr::to_int_type(*p) == Tr::to_int_type(LEFT)) {
          ++p;
          m_leftJustify = true;
        }
      }
 
// If not at start, PUSH and POP are for the next line.
      else {
  if (Tr::to_int_type(*q) == Tr::to_int_type('\n')) {
    prefix();
    m_streamBuffer->sputn(p, q - p);
    next_line();
    p = q + 1;
  }
  else if (Tr::to_int_type(*q) == Tr::to_int_type(POP)) {
    prefix();
    m_streamBuffer->sputn(p, q - p);
    p = q + 1;
    if (m_nextIndentLevel != m_indentLevel)
      next_line();
    if (m_indentLevel > 0)
      m_nextIndentLevel = m_indentLevel - 1;
  }
  else if (Tr::to_int_type(*q) == Tr::to_int_type(PUSH)) {
    prefix();
    m_streamBuffer->sputn(p, q - p);
    p = q + 1;
    if (m_nextIndentLevel != m_indentLevel)
      next_line();
    m_nextIndentLevel = m_indentLevel + 1;
  }
        else if (Tr::to_int_type(*q) == Tr::to_int_type(LEFT)) {
          m_leftJustify = true;
    p = q + 1;
        }
      }
    }
    if (p != p_end) {
      prefix();
      m_streamBuffer->sputn(p, p_end - p);
      m_atLineBegin = false;
    }
 
    return n;
  }
 
  virtual int sync() {
    return m_streamBuffer->pubsync();
  }
 
private:
  basic_indent_streambuf(const basic_indent_streambuf &);
  basic_indent_streambuf &operator=(const basic_indent_streambuf &);
  
private:
  std::streambuf *  m_streamBuffer;         
  bool      m_atLineBegin;          
  bool                  m_leftJustify;          
  size_t    m_indentLevel;          
  size_t    m_nextIndentLevel;      
  size_t    m_indentSize;           
  Flags     m_flags;                
  Ch *      m_indentString;         
};
 
template<class Ch, class Tr>
std::basic_ostream<Ch, Tr> &push(std::basic_ostream<Ch, Tr> &os) {
  os.put(PUSH);
//  os.put('\n');
  os.flush();
  return os;
}
 
template<class Ch, class Tr>
std::basic_ostream<Ch, Tr> &pop(std::basic_ostream<Ch, Tr> &os) {
  os.put(POP);
//  os.put('\n');
  os.flush();
  return os;
}
 
 
template<class Ch, class Tr>
class indent_streambuf_throwsafe
{
  explicit indent_streambuf_throwsafe(basic_indent_streambuf<Ch, Tr> &sb)
    : m_indentStreambuf(sb),
      m_indentLevel(sb.indent_level())
  {}
 
  ~indent_streambuf_throwsafe() {
    while (m_indentStreambuf.indent_level() > m_indentLevel)
      m_indentStreambuf.pop();
  }
 
private:
  basic_indent_streambuf<Ch, Tr> &      m_indentStreambuf;
  size_t                                m_indentLevel;
};
 
 
struct IndentFlags {
  int           m_flags;
};
 
inline IndentFlags indent_flags(int flags) {
  IndentFlags f;
  f.m_flags = flags;
  return f;
}
 
template<class Ch, class Tr>
std::basic_ostream<Ch, Tr> &
operator<<(std::basic_ostream<Ch, Tr> &os, IndentFlags indent_flags) {
  basic_indent_streambuf<Ch, Tr> *osb = dynamic_cast<basic_indent_streambuf<Ch, Tr> *>(os.rdbuf());
  if (osb)
    osb->set_flags(indent_flags.m_flags);
      
  return os;
}
 
typedef stk_classic::basic_indent_streambuf<char> indent_streambuf;
 
} // namespace stk_classic
 
#endif //  STK_UTIL_UTIL_INDENTSTREAMBUF_HPP