Term::Buffer Class Reference

#include <cpp-terminal/buffer.hpp>

Inheritance diagram for Term::Buffer:

Public Types
enum class	Type : std::uint8_t { Unbuffered , LineBuffered , FullBuffered }

Public Member Functions
	Buffer (const Term::Buffer::Type &type=Term::Buffer::Type::LineBuffered, const std::streamsize &size=BUFSIZ)
	~Buffer () override
	Buffer (const Buffer &)=delete
	Buffer (Buffer &&)=delete
Buffer &	operator= (Buffer &&)=delete
Buffer &	operator= (const Buffer &)=delete

Protected Member Functions
int_type	underflow () override
int_type	overflow (int c=std::char_traits< Term::Buffer::char_type >::eof()) override
int	sync () override

Private Member Functions
void	setType (const Term::Buffer::Type &type)
std::streambuf *	setbuf (char *s, std::streamsize n) override

Private Attributes
std::string	m_buffer
Term::Buffer::Type	m_type {Term::Buffer::Type::LineBuffered}

Detailed Description

Definition at line 19 of file buffer.hpp.

Member Enumeration Documentation

Type

enum class Term::Buffer::Type : std::uint8_t

strong

Enumerator
Unbuffered
LineBuffered
FullBuffered

Definition at line 22 of file buffer.hpp.

  {
    Unbuffered,
    LineBuffered,
    FullBuffered
  };

Constructor & Destructor Documentation

Buffer() [1/3]

Term::Buffer::Buffer ( const Term::Buffer::Type & type = Term::Buffer::Type::LineBuffered, const std::streamsize & size = BUFSIZ )

explicit

Definition at line 47 of file buffer.cpp.

{
  setType(type);
  switch(m_type)
  {
    case Type::Unbuffered: setbuf(nullptr, 0); break;
    case Type::LineBuffered:
    case Type::FullBuffered: setbuf(&m_buffer[0], size); break;
  }
}

~Buffer()

Term::Buffer::~Buffer ( )

override

Definition at line 149 of file buffer.cpp.

{
  //sync();
}

Buffer() [2/3]

Term::Buffer::Buffer ( const Buffer & )

delete

Buffer() [3/3]

Term::Buffer::Buffer ( Buffer && )

delete

Member Function Documentation

operator=() [1/2]

Buffer & Term::Buffer::operator= ( Buffer && )

delete

operator=() [2/2]

Buffer & Term::Buffer::operator= ( const Buffer & )

delete

overflow()

Term::Buffer::int_type Term::Buffer::overflow ( int c = std::char_traits<Term::Buffer::char_type>::eof() )

overrideprotected

Definition at line 113 of file buffer.cpp.

{
  if(c != std::char_traits<Term::Buffer::char_type>::eof())
  {
    switch(m_type)
    {
      case Type::Unbuffered:
      {
        Term::Private::out.write(replace(c));
        break;
      }
      case Type::LineBuffered:
      {
        m_buffer += replace(c);
        if(static_cast<char>(c) == '\n')
        {
          Term::Private::out.write(m_buffer);
          m_buffer.clear();
        }
        break;
      }
      case Type::FullBuffered:
      {
        if(m_buffer.size() >= m_buffer.capacity())
        {
          Term::Private::out.write(m_buffer);
          m_buffer.clear();
        }
        m_buffer += replace(c);
        break;
      }
    }
  }
  return c;
}

setbuf()

std::streambuf * Term::Buffer::setbuf ( char * s, std::streamsize n )

overrideprivate

Definition at line 60 of file buffer.cpp.

{
  if(s != nullptr) m_buffer.reserve(static_cast<std::size_t>(n));
  return this;
}

setType()

void Term::Buffer::setType ( const Term::Buffer::Type & type )

private

Definition at line 58 of file buffer.cpp.

{ m_type = type; }

sync()

int Term::Buffer::sync ( )

overrideprotected

Definition at line 40 of file buffer.cpp.

{
  const int ret = Term::Private::out.write(m_buffer);
  m_buffer.clear();
  return ret;
}

underflow()

Term::Buffer::int_type Term::Buffer::underflow ( )

overrideprotected

Definition at line 66 of file buffer.cpp.

{
  try
  {
    //TODO Maybe use input function ?
    m_buffer.clear();
    if(terminal.getOptions().has(Option::Raw))
    {
      do {
        std::string ret{Term::Private::in.read()};
        if(!ret.empty())
        {
          if(ret[0] == '\x7f' || ret[0] == '\b')
          {
            Term::Private::out.write("\b \b");  //Backspace is DEL, CTRL+Backspace is Backspace '\b'
            if(!m_buffer.empty()) m_buffer.erase(m_buffer.size() - 1);
          }
          else if(ret[0] == '\033')
          {
            continue;  // For now if it's escape sequence do nothing
          }
          else if(ret[0] <= 31 && ret[0] != '\t' && ret[0] != '\b' && ret[0] != 127 && ret[0] != ' ' && ret[0] != '\n' && ret[0] != '\r') { continue; }
          else
          {
            Term::Private::out.write(ret);
            m_buffer += ret;
          }
        }
      } while(m_buffer.empty() || !newline_sequence(m_buffer));
      Term::Private::out.write('\n');
    }
    else
    {
      do {
        std::string ret{Term::Private::in.read()};
        m_buffer += ret;
      } while(m_buffer.empty());
    }
    setg(&m_buffer[0], &m_buffer[0], &m_buffer[0] + m_buffer.size());
    return traits_type::to_int_type(m_buffer.at(0));
  }
  catch(...)
  {
    return traits_type::eof();
  }
}

Member Data Documentation

m_buffer

std::string Term::Buffer::m_buffer

private

Definition at line 43 of file buffer.hpp.

m_type

Term::Buffer::Type Term::Buffer::m_type {Term::Buffer::Type::LineBuffered}

private

Definition at line 44 of file buffer.hpp.

{Term::Buffer::Type::LineBuffered};

---

The documentation for this class was generated from the following files:

• cpp-terminal/buffer.hpp
• cpp-terminal/buffer.cpp