commons::st_reader Class Reference

Convenience class for reading from sockets. More...

#include <st.h>

Collaboration diagram for commons::st_reader:

[legend]

List of all members.

Public Member Functions
	st_reader (st_netfd_t fd, char *buf, size_t bufsize)
size_t	unread ()
	The size of the unconsumed range of bytes.
size_t	rem ()
	The remaining number of bytes in the buffer.
sized_array< char > &	buf ()
	The entire read buffer.
void	reset_range (char *start, char *end)
	Manually update/adjust the pointers; useful after changing buf_.
void	skip (size_t req, st_utime_t to=ST_UTIME_NO_TIMEOUT)
	Discard the requested number of bytes.
managed_array< char >	read (size_t req, st_utime_t to=ST_UTIME_NO_TIMEOUT)
	Returns a char array that contains the requested number of bytes.
template<typename T>
T	read (st_utime_t to=ST_UTIME_NO_TIMEOUT)

---

Detailed Description

Convenience class for reading from sockets.

Definition at line 382 of file st.h.

---

Member Function Documentation

managed_array<char> commons::st_reader::read	(	size_t	req,
		st_utime_t	to = ST_UTIME_NO_TIMEOUT
	)			[inline]

Returns a char array that contains the requested number of bytes.

If we hit an error or EOF, then an exception is thrown.

Definition at line 445 of file st.h.

References commons::sized_array< T >::end(), commons::sized_array< T >::get(), commons::managed_array< T >::get(), rem(), commons::sized_array< T >::size(), and unread().

                                                                                {
        // Do we already have the requested data?
        if (unread() >= req) {
          managed_array<char> p(start_, false);
          start_ += req;
          return p;
        }

        // Handle large arrays specially.
        if (req > buf_.size()) {
          managed_array<char> p(new char[req], true);
          memcpy(p.get(), start_, unread());
          checkeqnneg(st_read_fully(fd_, p + unread(), req - unread(), to), static_cast<ssize_t>(req - unread()));
          start_ = end_ = buf_.get();
          return p;
        }

        // Shift things down if necessary.
        if (req > static_cast<size_t>(buf_.end() - end_)) {
          memmove(buf_.get(), start_, unread());
          size_t diff = start_ - buf_.get();
          start_ -= diff;
          end_ -= diff;
        }

        // Keep reading until we have enough.
        while (unread() < req) {
          ssize_t res = checknnegerr(st_read(fd_, end_, rem(), to));
          if (res == 0) break;
          else end_ += res;
        }

        // If we got a premature EOF.
        if (unread() < req)
          throw eof_exception();

        managed_array<char> p(start_, false);
        start_ += req;
        return p;
      }

Here is the call graph for this function:

---

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

• src/commons/st/st.h