streambuf.cpp

Go to the documentation of this file.

#include "../include/streambuf.hpp"
#include "../include/util.hpp"
#if !defined CSDBG_WITH_PLUGIN && !defined CSDBG_WITH_HIGHLIGHT
#include "../include/exception.hpp"
#endif

namespace csdbg {

streambuf::streambuf()
try:
string(),
m_handle(-1)
{
}

catch (...) {
  m_handle = -1;
}


streambuf::streambuf(const streambuf &src)
try:
string(),
m_handle(-1)
{
  *this = src;
}

catch (...) {
  delete[] m_data;
  m_data = NULL;
  m_handle = -1;
}


streambuf::~streambuf()
{
  close();
}


inline i32 streambuf::handle() const
{
  return m_handle;
}


inline bool streambuf::is_opened() const
{
  return m_handle >= 0;
}


streambuf& streambuf::operator=(const streambuf &rval)
{
  if ( unlikely(this == &rval) )
    return *this;

  /* Close the current stream (to sync current data) */
  close();

  /* Copy the buffer */
  string::operator=(rval);

  i32 fd = rval.m_handle;
  if ( unlikely(fd < 0) )
    return *this;

  /* Duplicate the handle (descriptor) */
  m_handle = dup(fd);
  if ( unlikely(m_handle < 0) )
    throw exception(
      "failed to duplicate descriptor %d (errno %d - %s)",
      fd,
      errno,
      strerror(errno)
    );

  return *this;
}


streambuf& streambuf::close()
{
  if ( likely(m_handle >= 0) ) {
    i32 retval;
    do {
      retval = ::close(m_handle);
    }
    while ( unlikely(retval < 0 && errno == EINTR) );

    m_handle = -1;
  }

  return *this;
}


streambuf& streambuf::flush()
{
  i32 offset = 0, sz = m_length;
  while ( likely(sz > 0) ) {
    i32 written = write(m_handle, m_data + offset, sz);
    if ( unlikely(written < 0) )
      switch (errno) {
      case EINTR:
      case EAGAIN:
        continue;

      default:
        throw errno;
      }

    sz -= written;
    offset += written;
  }

  /* Clear the buffer */
  clear();
  return *this;
}


streambuf& streambuf::lock() const
{
  i32 retval;
  do {
    retval = flock(m_handle, LOCK_EX);
  }
  while ( unlikely(retval < 0 && errno == EINTR) );

  if ( unlikely(retval < 0) )
    throw errno;

  return const_cast<streambuf&> (*this);
}


streambuf& streambuf::unlock() const
{
  i32 retval;
  do {
    retval = flock(m_handle, LOCK_UN);
  }
  while ( unlikely(retval < 0 && errno == EINTR) );

  if ( unlikely(retval < 0) )
    throw errno;

  return const_cast<streambuf&> (*this);
}


streambuf& streambuf::header()
{
  const i8 *path = util::exec_path();

  struct timeval now;
  gettimeofday(&now, NULL);
  u64 tstamp = static_cast<u64> (now.tv_sec) * 10e+5 + now.tv_usec;

  try {
    append("path: %s\r\n", path);
    append("pid: %x\r\n", getpid());
    append("tid: %lx\r\n", pthread_self());
    append("tstamp: %lx\r\n", tstamp);

    delete[] path;
    return *this;
  }

  catch (...) {
    delete[] path;
    throw;
  }
}

}