debugStream.h

// Copyright 2009-2026 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2026, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.
 
#ifndef SST_CORE_IMPL_INTERACTIVE_DEBUGSTREAM_H
#define SST_CORE_IMPL_INTERACTIVE_DEBUGSTREAM_H
 
#include <cstddef>
#include <cstdint>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
 
namespace SST::IMPL::Interactive {
 
// Overloaded streambuffer for use with DebuggerStream class
// ** This class is intended for use with the interactive console ONLY **
// This streambuffer will limit the size, in terms of line width and
// lines per screen, of output. Wide output (wider than charsPerLine_)
// will be truncated with a '...' and output that goes beyond
// linesPerScreen will prompt the user to continue or cancel
 
class DebuggerStreamBuf : public std::streambuf
{
private:
    std::streambuf* dest_;
    unsigned        linesPerScreen_;
    unsigned        curLines_;
    bool            paginate_;
    bool            quit_;
    unsigned        charsPerLine_;
    unsigned        curChars_;
    bool            confirm_;
 
protected:
    virtual int_type overflow(int_type c) override;
    virtual int      sync() override;
 
 
public:
    DebuggerStreamBuf(std::streambuf* dest, unsigned linesPerScreen, unsigned charsPerLine) :
        dest_(dest),
        linesPerScreen_(linesPerScreen),
        curLines_(0),
        paginate_(true),
        quit_(false),
        charsPerLine_(charsPerLine),
        curChars_(0),
        confirm_(true)
    {}
 
    void reset()
    {
        if ( confirm_ )
            paginate_ = true;
        else
            paginate_ = false;
        quit_     = false;
        curLines_ = 0;
        curChars_ = 0;
    }
 
    void setConfirm(bool c)
    {
        confirm_  = c;
        paginate_ = c;
    }
 
    void     setLineWidth(const unsigned w) { charsPerLine_ = w; }
    void     setLineCount(const unsigned c) { linesPerScreen_ = c; }
    unsigned getLineWidth() { return charsPerLine_; }
};
 
// ** This class is intended for use with the interactive console ONLY **
// When
 
class DebuggerStream : public std::ostream
{
private:
    DebuggerStreamBuf buf_;
 
public:
    DebuggerStream(std::ostream& dest, unsigned linesPerScreen, unsigned charsPerLine) :
        std::ostream(&buf_),
        buf_(dest.rdbuf(), linesPerScreen, charsPerLine)
    {}
 
    void reset()
    {
        buf_.reset();
        clear();
    }
 
    void setConfirm(bool c) { buf_.setConfirm(c); }
 
 
    void     setLineWidth(const unsigned w) { buf_.setLineWidth(w); }
    void     setLineCount(const unsigned c) { buf_.setLineCount(c); }
    unsigned getLineWidth() { return buf_.getLineWidth(); }
};
 
// Overload << to cpature all function pointers, used in conjunction
// with dreset.
 
inline DebuggerStream&
operator<<(DebuggerStream& stream, DebuggerStream& (*func)(DebuggerStream&))
{
    return func(stream);
}
 
// Call this function to reset the DebuggerStreamBuf back to a
// known good state after each use. This is required to allow it
// to recover from a potential `EOF` that has been inserted
// when the user elects to stop output
 
inline DebuggerStream&
dreset(DebuggerStream& stream)
{
    stream.reset();
    stream.flush();
    return stream;
}
 
 
} // namespace SST::IMPL::Interactive
 
#endif