Teuchos_FancyOStream_decl.hpp

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_FANCY_O_STREAM_DECL_HPP
#define TEUCHOS_FANCY_O_STREAM_DECL_HPP
 
#include "Teuchos_RCP.hpp"
#include "Teuchos_GlobalMPISession.hpp"
#include "Teuchos_oblackholestream.hpp"
#include "Teuchos_as.hpp"
#include <deque>
 
namespace Teuchos {
 
 
template<typename CharT, typename Traits>
class basic_FancyOStream_buf : public std::basic_streambuf<CharT,Traits>
{
public:
 
  typedef CharT char_type;
  typedef Traits                                         traits_type;
  typedef typename traits_type::int_type                int_type;
  typedef typename traits_type::pos_type                pos_type;
  typedef typename traits_type::off_type                off_type;
 
  basic_FancyOStream_buf(
    const RCP<std::basic_ostream<char_type,traits_type> > &oStream
    ,const std::basic_string<char_type,traits_type> &tabIndentStr
    ,const int startingTab
    ,const bool showLinePrefix
    ,const int maxLenLinePrefix
    ,const bool showTabCount
    ,const bool showProcRank
    );
 
  void initialize(
    const RCP<std::basic_ostream<char_type,traits_type> > &oStream
    ,const std::basic_string<char_type,traits_type> &tabIndentStr
    ,const int startingTab
    ,const bool showLinePrefix
    ,const int maxLenLinePrefix
    ,const bool showTabCount
    ,const bool showProcRank
    );
 
  RCP<std::basic_ostream<char_type,traits_type> > getOStream();
 
  void setTabIndentStr(const std::basic_string<char_type,traits_type> &tabIndentStr);
 
  const std::basic_string<char_type,traits_type>& getTabIndentStr() const;
 
  void setShowLinePrefix(const bool showLinePrefix);
 
  bool getShowLinePrefix() const;
 
  void setMaxLenLinePrefix(const int maxLenLinePrefix);
 
  int getMaxLenLinePrefix() const;
 
  void setShowTabCount(const bool showTabCount);
 
  bool getShowTabCount() const;
 
  void setShowProcRank(const bool showProcRank);
 
  bool getShowProcRank() const;
 
  void setProcRankAndSize( const int procRank, const int numProcs );
 
  int getProcRank() const;
 
  int getNumProcs() const;
 
  void setOutputToRootOnly( const int rootRank );
 
  int getOutputToRootOnly() const;
 
  void pushTab(const int tabs);
 
  int getNumCurrTabs() const;
 
  void popTab();
 
  void pushLinePrefix(
    const std::basic_string<char_type,traits_type> &linePrefix
    );
 
  void popLinePrefix();
 
  const std::basic_string<char_type,traits_type>& getTopLinePrefix() const;
 
  void pushDisableTabbing();
 
  void popDisableTabbing();
 
protected:
 
 
 
  std::streamsize xsputn(const char_type* s, std::streamsize n);
 
  int_type overflow(int_type c);
 
#ifdef TEUCHOS_FANCY_OSTREAM_SHOW_ALL_CALLS
 
  void imbue(const locale& l)
    {
      std::cerr << "\ncalled imbue()\n";
      std::basic_streambuf<CharT,Traits>::imbue(l);
    }
 
  basic_streambuf<char_type,Traits>*
  setbuf(char_type* s, streamsize n)
    {
      std::cerr << "\ncalled setbuf()\n";
      return std::basic_streambuf<CharT,Traits>::setbuf(s,n);
    }
 
  pos_type
  seekoff(off_type a, ios_base::seekdir b,ios_base::openmode c)
    {
      std::cerr << "\ncalled seekoff()\n";
      return std::basic_streambuf<CharT,Traits>::seekoff(a,b,c);
    }
 
  pos_type
  seekpos(pos_type a, ios_base::openmode b)
    {
      std::cerr << "\ncalled seekpos()\n";
      return std::basic_streambuf<CharT,Traits>::seekpos(a,b);
    }
 
  int
  sync()
    {
      std::cerr << "\ncalled sync()\n";
      return std::basic_streambuf<CharT,Traits>::sync();
    }
 
  streamsize
  showmanyc()
    {
      std::cerr << "\ncalled showmanyc()\n";
      return std::basic_streambuf<CharT,Traits>::showmanyc();
    }
 
  streamsize
  xsgetn(char_type* s, streamsize n)
    {
      std::cerr << "\ncalled xsgetn()\n";
      return std::basic_streambuf<CharT,Traits>::xsgetn(s,n);
    }
 
  int_type
  underflow()
    {
      std::cerr << "\ncalled underflow()\n";
      return std::basic_streambuf<CharT,Traits>::underflow();
    }
 
  int_type
  uflow()
    {
      std::cerr << "\ncalled uflow()\n";
      return std::basic_streambuf<CharT,Traits>::uflow();
    }
 
  int_type
  pbackfail(int_type c = traits_type::eof())
    {
      std::cerr << "\ncalled pbackfail()\n";
      return std::basic_streambuf<CharT,Traits>::pbackfail(c);
    }
 
#endif // TEUCHOS_FANCY_OSTREAM_SHOW_ALL_CALLS
 
 
private:
 
  // ////////////////////////
  // Private types
 
  typedef std::basic_string<char_type,traits_type> string_t;
  typedef std::deque<int> tabIndentStack_t;
  typedef std::deque<string_t> linePrefixStack_t;
 
  // ////////////////////////
  // Private data members
 
  RCP<std::basic_ostream<char_type,traits_type> > oStreamSet_;
  RCP<std::basic_ostream<char_type,traits_type> > oStream_;
  std::basic_string<char_type,traits_type> tabIndentStr_;
  bool showLinePrefix_;
  int maxLenLinePrefix_;
  bool showTabCount_;
  bool showProcRank_;
  int rootRank_;
  int procRank_;
  int numProcs_;
  int rankPrintWidth_;
 
  RCP<std::ostringstream> lineOut_;
 
  int tabIndent_;
  tabIndentStack_t tabIndentStack_;
  linePrefixStack_t linePrefixStack_;
  int enableTabbingStack_;
 
  bool wroteNewline_;
 
  // ////////////////////////
  // Private member functions
 
  std::ostream& out();
 
  void writeChars( const char_type s[], std::streamsize n );
 
  void writeFrontMatter();
 
  // Not defined and not to be called
  basic_FancyOStream_buf();
  basic_FancyOStream_buf(const basic_FancyOStream_buf<CharT,Traits>&);
  basic_FancyOStream_buf<CharT,Traits> operator=(
    const basic_FancyOStream_buf<CharT,Traits>&
    );
 
};
 
 
template <typename CharT, typename Traits = std::char_traits<CharT> >
class basic_FancyOStream : public std::basic_ostream<CharT, Traits>
{
public:
 
 
 
  typedef CharT char_type;
  typedef Traits traits_type;
  typedef typename traits_type::int_type int_type;
  typedef typename traits_type::pos_type pos_type;
  typedef typename traits_type::off_type off_type;
  typedef basic_FancyOStream_buf<CharT,Traits> streambuf_t;
  typedef std::basic_ostream<char_type, traits_type> ostream_t;
 
 
 
 
  explicit
  basic_FancyOStream(
    const RCP< std::basic_ostream<char_type,traits_type> > &oStream
    ,const std::basic_string<char_type,traits_type> &tabIndentStr = " "
    ,const int startingTab = 0
    ,const bool showLinePrefix = false
    ,const int maxLenLinePrefix = 10
    ,const bool showTabCount = false
    ,const bool showProcRank = false
    );
 
  void initialize(
    const RCP< std::basic_ostream<char_type,traits_type> > &oStream
    ,const std::basic_string<char_type,traits_type> &tabIndentStr = " "
    ,const int startingTab = 0
    ,const bool showLinePrefix = false
    ,const int maxLenLinePrefix = 10
    ,const bool showTabCount = false
    ,const bool showProcRank = false
    );
 
  RCP<std::basic_ostream<char_type,traits_type> > getOStream();
 
  basic_FancyOStream& setTabIndentStr(
    const std::basic_string<char_type,traits_type> &tabIndentStr
    );
 
  const std::basic_string<char_type,traits_type>& getTabIndentStr() const;
 
  basic_FancyOStream& setShowAllFrontMatter(const bool showAllFrontMatter);
 
  basic_FancyOStream& setShowLinePrefix(const bool showLinePrefix);
 
  basic_FancyOStream& setMaxLenLinePrefix(const int maxLenLinePrefix);
 
  basic_FancyOStream& setShowTabCount(const bool showTabCount);
 
  basic_FancyOStream& setShowProcRank(const bool showProcRank);
 
  basic_FancyOStream& setProcRankAndSize( const int procRank, const int numProcs );
 
  basic_FancyOStream& setOutputToRootOnly( const int rootRank );
 
  int getOutputToRootOnly() const;
 
  void copyAllOutputOptions(const basic_FancyOStream<CharT,Traits> &oStream);
 
 
 
 
  void pushTab(const int tabs = 1);
 
  int getNumCurrTabs() const;
 
  void popTab();
 
  void pushLinePrefix(const std::basic_string<char_type,traits_type> &linePrefix);
 
  void popLinePrefix();
 
  const std::basic_string<char_type,traits_type>& getTopLinePrefix() const;
 
  void pushDisableTabbing();
 
  void popDisableTabbing();
 
 
private:
 
  streambuf_t   streambuf_;
 
  // Not defined and not to be called
  basic_FancyOStream();
  basic_FancyOStream(const basic_FancyOStream<CharT,Traits>&);
  basic_FancyOStream<CharT,Traits> operator=(const basic_FancyOStream<CharT,Traits>&);
 
};
 
 
RCP<basic_FancyOStream<char> >
fancyOStream(
  const RCP< std::basic_ostream<char> >& oStream,
  const std::basic_string<char>& tabIndentStr = " ",
  const int startingTab = 0,
  const bool showLinePrefix = false,
  const int maxLenLinePrefix = 10,
  const bool showTabCount = false,
  const bool showProcRank = false
             );
 
 
RCP<basic_FancyOStream<char> >
getFancyOStream( const RCP<std::basic_ostream<char> > &out );
 
 
template <typename CharT, typename Traits = std::char_traits<CharT> >
class basic_OSTab
{
public:
 
  static const int DISABLE_TABBING = -99999; // This magic number should be just fine!
  basic_OSTab(
    const RCP<basic_FancyOStream<CharT,Traits> > &fancyOStream
    ,const int tabs = 1
    ,const std::basic_string<CharT,Traits> linePrefix = ""
    )
    :fancyOStream_(fancyOStream)
    ,tabs_(tabs)
    ,linePrefix_(linePrefix)
    {
      updateState();
    }
  basic_OSTab(
    const RCP<std::basic_ostream<CharT,Traits> > &oStream
    ,const int tabs = 1
    ,const std::basic_string<CharT,Traits> linePrefix = ""
    )
    :fancyOStream_(getFancyOStream(oStream))
    ,tabs_(tabs)
    ,linePrefix_(linePrefix)
    {
      updateState();
    }
  basic_OSTab(
    basic_FancyOStream<CharT,Traits> &fancyOStream
    ,const int tabs = 1
    ,const std::basic_string<CharT,Traits> linePrefix = ""
    )
    :fancyOStream_(rcp(&fancyOStream,false))
    ,tabs_(tabs)
    ,linePrefix_(linePrefix)
    {
      updateState();
    }
  basic_OSTab(
    std::basic_ostream<CharT,Traits> &oStream
    ,const int tabs = 1
    ,const std::basic_string<CharT,Traits> linePrefix = ""
    )
    :fancyOStream_(getFancyOStream(rcp(&oStream, false)))
    ,tabs_(tabs)
    ,linePrefix_(linePrefix)
    {
      updateState();
    }
  basic_OSTab( const basic_OSTab &osTab )
    :fancyOStream_(osTab.fancyOStream_)
    ,tabs_(osTab.tabs_)
    {
      updateState();
    }
  ~basic_OSTab()
    {
      if(fancyOStream_.get()) {
        if(tabs_==DISABLE_TABBING)
          fancyOStream_->popDisableTabbing();
        else
          fancyOStream_->popTab();
        if(linePrefix_.length()) fancyOStream_->popLinePrefix();
      }
    }
  basic_OSTab<CharT,Traits>& operator=( const basic_OSTab &osTab )
    {
      fancyOStream_ = osTab.fancyOStream_;
      tabs_ = osTab.tabs_;
      updateState();
      return *this;
    }
  basic_OSTab<CharT,Traits>& incrTab(const int tabs = 1)
    {
      tabs_ += tabs;
      if(fancyOStream_.get()) {
        fancyOStream_->popTab();
        fancyOStream_->pushTab(tabs_);
      }
      return *this;
    }
  basic_FancyOStream<CharT,Traits>& o() const
    {
      return *fancyOStream_;
    }
  basic_FancyOStream<CharT,Traits>* get() const
    {
      return fancyOStream_.get();
    }
 
private:
 
  RCP<basic_FancyOStream<CharT,Traits> > fancyOStream_;
  int tabs_;
  std::basic_string<CharT,Traits> linePrefix_;
 
  void updateState()
    {
      if(fancyOStream_.get()) {
        if(tabs_==DISABLE_TABBING)
          fancyOStream_->pushDisableTabbing();
        else
          fancyOStream_->pushTab(tabs_);
        if(linePrefix_.length()) fancyOStream_->pushLinePrefix(linePrefix_);
      }
    }
 
};
 
 
template <typename CharT, typename Traits>
RCP<basic_FancyOStream<CharT,Traits> >
tab(
  const RCP<basic_FancyOStream<CharT,Traits> > &out,
  const int tabs = 1,
  const std::basic_string<CharT,Traits> linePrefix = ""
    );
 
 
template <typename CharT, typename Traits>
RCP<basic_FancyOStream<CharT,Traits> >
tab(
  const RCP<std::basic_ostream<CharT,Traits> > &out
  ,const int tabs = 1
  ,const std::basic_string<CharT,Traits> linePrefix = ""
    );
 
 
// ///////////////////////////////
// Typedefs
 
 
typedef basic_FancyOStream<char> FancyOStream;
 
 
typedef basic_OSTab<char> OSTab;
 
 
#define TEUCHOS_OSTAB ::Teuchos::OSTab __localThisTab = this->getOSTab()
 
#define TEUCHOS_OSTAB_DIFF( DIFF ) ::Teuchos::OSTab DIFF ## __localThisTab = this->getOSTab()
 
} // namespace Teuchos
 
 
#endif // TEUCHOS_FANCY_O_STREAM_DECL_HPP