IOChannel Class Reference

#include <IOChannel.h>

Inheritance diagram for IOChannel:

Public Member Functions
virtual void	close (void)
virtual IOFD	fd (void) const
virtual void	fd (IOFD value)
	IOChannel (IOFD fd=-1)
virtual bool	isBlocking (void) const
IOSize	read (void *into, IOSize n) override
IOSize	readv (IOBuffer *into, IOSize buffers) override
virtual void	setBlocking (bool value)
IOSize	write (const void *from, IOSize n) override
IOSize	writev (const IOBuffer *from, IOSize buffers) override
	~IOChannel (void) override
Public Member Functions inherited from IOInput
int	read (void)
IOSize	read (IOBuffer into)
IOSize	xread (IOBuffer into)
IOSize	xread (void *into, IOSize n)
IOSize	xreadv (IOBuffer *into, IOSize buffers)
virtual	~IOInput (void)
	Destruct the stream. A no-op. More...
Public Member Functions inherited from IOOutput
IOSize	write (unsigned char byte)
IOSize	write (IOBuffer from)
IOSize	xwrite (const void *from, IOSize n)
IOSize	xwrite (IOBuffer from)
IOSize	xwritev (const IOBuffer *from, IOSize buffers)
virtual	~IOOutput (void)
	Destruct the stream. A no-op. More...

Protected Member Functions
bool	sysclose (IOFD fd, int *error=nullptr)

Private Attributes
IOFD	m_fd

Detailed Description

Base class for stream-oriented I/O sources and targets, based on the operating system file descriptor.

Definition at line 9 of file IOChannel.h.

Constructor & Destructor Documentation

IOChannel::IOChannel

(

IOFD

fd = -1

)

Definition at line 61 of file IOChannel.cc.

: m_fd(fd) {}

IOChannel::~IOChannel ( void  )

override

Definition at line 63 of file IOChannel.cc.

{}

Member Function Documentation

void IOChannel::close ( void  )

virtual

Close the channel. By default closes the underlying operating system file descriptor.

Reimplemented in File, and RemoteFile.

Definition at line 84 of file IOChannel.cc.

References EDM_IOFD_INVALID, relativeConstraints::error, fd(), sysclose(), and throwStorageError().

Referenced by esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), Vispa.Gui.FindDialog.FindDialog::keyPressEvent(), and sysclose().

                          {
  if (fd() == EDM_IOFD_INVALID)
    return;

  int error = 0;
  if (!sysclose(fd(), &error))
    throwStorageError("FileCloseError", "Calling IOChannel::close()", "sysclose()", error);

  fd(EDM_IOFD_INVALID);
}

IOFD IOChannel::fd ( void  ) const

virtual

Get the system file descriptor of the channel.

Definition at line 69 of file IOChannel.cc.

References m_fd.

Referenced by close(), File::duplicate(), isBlocking(), RemoteFile::local(), read(), readv(), setBlocking(), write(), writev(), and RemoteFile::~RemoteFile().

{ return m_fd; }

void IOChannel::fd ( IOFD  value )

virtual

Set the system file descriptor of the channel. (FIXME: This is dangerous. How to deal with WIN32 flags and state object?)

Definition at line 73 of file IOChannel.cc.

References m_fd, and relativeConstraints::value.

                             {
  // FIXME: close old one?
  // FIXME: reset state?
  m_fd = value;
}

bool IOChannel::isBlocking ( void  ) const

virtual

Definition at line 112 of file UnixIOChannel.cc.

References fd(), ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, O_NONBLOCK, and throwStorageError().

                                     {
#ifdef O_NONBLOCK
  int mode;
  if ((mode = fcntl(fd(), F_GETFL, 0)) == -1)
    throwStorageError("FileIsBlockingError", "Calling IOChannel::isBlocking()", "fcntl()", errno);

  return mode & (O_NDELAY | O_NONBLOCK);
#else   // ! O_NONBLOCK
  return true;
#endif  // O_NONBLOCK
}

IOSize IOChannel::read ( void *  into, IOSize  n  )

overridevirtual

Read at most n bytes from the channel into the buffer into.

Returns

The number of bytes actually read into the buffer. This is always less or equal to n. It can be less if there is limited amount of input currently available; zero means that the end of file has been reached. For a connected channel like a socket or pipe this indicates the remote end has closed the connection. If the channel is in non-blocking mode and no input is currently available, an exception is thrown (FIXME: make this simpler; clarify which exception?).

Implements IOInput.

Definition at line 9 of file UnixIOChannel.cc.

References fd(), edm::errors::FileReadError, IOInput::read(), alignCSCRings::s, and throwStorageError().

                                           {
  ssize_t s;
  do
    s = ::read(fd(), into, n);
  while (s == -1 && errno == EINTR);

  if (s == -1)
    throwStorageError(edm::errors::FileReadError, "Calling IOChannel::read()", "read()", errno);

  return s;
}

IOSize IOChannel::readv ( IOBuffer *  into, IOSize  buffers  )

overridevirtual

Read into scattered buffers.

This operation may ignore errors. If some data are already read and an error occurs, the call returns the number of bytes read up to that point, hiding the error. It is assumed that a subsequent read will discover persistent errors and that sporadic errors such as indication that the read would block can be ignored.

The operation always fills a buffer completely before proceeding to the next one. The call is handled by the operating system if possible; the fall back is to use the single read() repeatedly.

Reimplemented from IOInput.

Definition at line 21 of file UnixIOChannel.cc.

References data, fd(), edm::errors::FileReadError, mps_fire::i, dqmiodumpmetadata::n, IOBuffer::size(), and throwStorageError().

Referenced by File::readv().

                                                      {
  assert(!buffers || into);

  // readv may not support zero buffers.
  if (!buffers)
    return 0;

  ssize_t n = 0;

  // Convert the buffers to system format.
  std::vector<iovec> bufs(buffers);
  for (IOSize i = 0; i < buffers; ++i) {
    bufs[i].iov_len = into[i].size();
    bufs[i].iov_base = (caddr_t)into[i].data();
  }

  // Read as long as signals cancel the read before doing anything.
  do
    n = ::readv(fd(), &bufs[0], buffers);
  while (n == -1 && errno == EINTR);

  // If it was serious error, throw it.
  if (n == -1)
    throwStorageError(edm::errors::FileReadError, "Calling IOChannel::readv", "readv()", errno);

  // Return the number of bytes actually read.
  return n;
}

void IOChannel::setBlocking ( bool  value )

virtual

Definition at line 97 of file UnixIOChannel.cc.

References fd(), ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, O_NONBLOCK, throwStorageError(), and relativeConstraints::value.

                                      {
#ifdef O_NONBLOCK
  int mode;
  int off = value ? ~0 : ~(O_NDELAY | O_NONBLOCK);
  int on = value ? O_NONBLOCK : 0;

  if ((mode = fcntl(fd(), F_GETFL, 0)) == -1 || fcntl(fd(), F_SETFL, (mode & off) | on) == -1)
    throwStorageError("FileSetBlockingError", "Calling IOChannel::setBlocking()", "fcntl()", errno);
#elif defined FIONBIO
  int mode = value;
  if (ioctl(fd(), FIONBIO, &value) == -1)
    throwStorageError("FileSetBlockingError", "Calling IOChannel::setBlocking()", "ioctl()", errno);
#endif
}

bool IOChannel::sysclose ( IOFD  fd, int *  error = nullptr  )

protected

Definition at line 127 of file UnixIOChannel.cc.

References close(), and runTheMatrix::ret.

Referenced by close().

                                              {
  int ret = ::close(fd);
  if (error)
    *error = errno;
  return ret != -1;
}

IOSize IOChannel::write ( const void *  from, IOSize  n  )

overridevirtual

Write n bytes from the buffer at from.

Returns

The number of bytes actually written. This is always less or equal to the size of the buffer (n). It can be less if the channel is unable to accept some of the output. This can happen among others if the channel is in non-blocking mode, but also for other implementation and platform-dependent reasons.

Implements IOOutput.

Definition at line 53 of file UnixIOChannel.cc.

References fd(), edm::errors::FileWriteError, alignCSCRings::s, and throwStorageError().

Referenced by File::write().

                                                  {
  ssize_t s;
  do
    s = ::write(fd(), from, n);
  while (s == -1 && errno == EINTR);

  if (s == -1 && errno != EWOULDBLOCK)
    throwStorageError(edm::errors::FileWriteError, "Calling IOChannel::write()", "write()", errno);

  return s >= 0 ? s : 0;
}

IOSize IOChannel::writev ( const IOBuffer *  from, IOSize  buffers  )

overridevirtual

Write from a scattered buffer.

This operation may ignore errors. If some data is already written and an error occurs, the call returns the number of bytes written up to that point, hiding the error. It is assumed that a subsequent write will discover persistent errors.

Always writes a complete buffer before proceeding to the next one. The call is delegated to the operating system if possible. If the system does not support this, falls back on multiple calls to single-buffer write().

Reimplemented from IOOutput.

Definition at line 65 of file UnixIOChannel.cc.

References data, fd(), edm::errors::FileWriteError, mps_fire::i, dqmiodumpmetadata::n, IOBuffer::size(), and throwStorageError().

Referenced by File::writev().

                                                             {
  assert(!buffers || from);

  // writev may not support zero buffers.
  if (!buffers)
    return 0;

  ssize_t n = 0;

  // Convert the buffers to system format.
  std::vector<iovec> bufs(buffers);
  for (IOSize i = 0; i < buffers; ++i) {
    bufs[i].iov_len = from[i].size();
    bufs[i].iov_base = (caddr_t)from[i].data();
  }

  // Read as long as signals cancel the read before doing anything.
  do
    n = ::writev(fd(), &bufs[0], buffers);
  while (n == -1 && errno == EINTR);

  // If it was serious error, throw it.
  if (n == -1)
    throwStorageError(edm::errors::FileWriteError, "Calling IOChannel::writev()", "writev()", errno);

  // Return the number of bytes actually written.
  return n;
}

Member Data Documentation

IOFD IOChannel::m_fd

private

Definition at line 38 of file IOChannel.h.

Referenced by fd().