folly::Subprocess::ReadLinesCallback< Callback > Class Template Reference

#include <Subprocess.h>

Classes
struct	StreamSplitterCallback

Public Member Functions
	ReadLinesCallback (Callback &&fdLineCb, uint64_t maxLineLength=0, char delimiter= '\n', uint64_t bufSize=1024)
bool	operator() (int pfd, int cfd)

Private Types
typedef gen::StreamSplitter< StreamSplitterCallback >	LineSplitter

Private Attributes
Callback	fdLineCb_
const uint64_t	maxLineLength_
const char	delimiter_
const uint64_t	bufSize_
std::unordered_map< int, LineSplitter >	fdToSplitter_

Detailed Description

template<class Callback>
class folly::Subprocess::ReadLinesCallback< Callback >

A readCallback for Subprocess::communicate() that helps you consume lines (or other delimited pieces) from your subprocess's file descriptors. Use the readLinesCallback() helper to get template deduction. For example:

subprocess.communicate( Subprocess::readLinesCallback( [](int fd, folly::StringPiece s) { std::cout << fd << " said: " << s; return false; // Keep reading from the child } ), [](int pdf, int cfd){ return true; } // Don't write to the child );

If a file line exceeds maxLineLength, your callback will get some initial chunks of maxLineLength with no trailing delimiters. The final chunk of a line is delimiter-terminated iff the delimiter was present in the input. In particular, the last line in a file always lacks a delimiter – so if a file ends on a delimiter, the final line is empty.

Like a regular communicate() callback, your fdLineCb() normally returns false. It may return true to tell Subprocess to close the underlying file descriptor. The child process may then receive SIGPIPE or get EPIPE errors on writes.

Definition at line 749 of file Subprocess.h.

Member Typedef Documentation

template<class Callback >

typedef gen::StreamSplitter<StreamSplitterCallback> folly::Subprocess::ReadLinesCallback< Callback >::LineSplitter

private

Definition at line 761 of file Subprocess.h.

Constructor & Destructor Documentation

template<class Callback >

folly::Subprocess::ReadLinesCallback< Callback >::ReadLinesCallback ( Callback &&  fdLineCb, uint64_t  maxLineLength = 0, char  delimiter = '\n', uint64_t  bufSize = 1024  )

inlineexplicit

Definition at line 764 of file Subprocess.h.

        : fdLineCb_(std::forward<Callback>(fdLineCb)),
          maxLineLength_(maxLineLength),
          delimiter_(delimiter),
          bufSize_(bufSize) {}

Member Function Documentation

template<class Callback >

bool folly::Subprocess::ReadLinesCallback< Callback >::operator() ( int  pfd, int  cfd  )

inline

Definition at line 774 of file Subprocess.h.

References folly::checkUnixError(), and folly::readNoInt().

                                      {
      // Make a splitter for this cfd if it doesn't already exist
      auto it = fdToSplitter_.find(cfd);
      auto& splitter = (it != fdToSplitter_.end())
          ? it->second
          : fdToSplitter_
                .emplace(
                    cfd,
                    LineSplitter(
                        delimiter_,
                        StreamSplitterCallback(fdLineCb_, cfd),
                        maxLineLength_))
                .first->second;
      // Read as much as we can from this FD
      char buf[bufSize_];
      while (true) {
        ssize_t ret = readNoInt(pfd, buf, bufSize_);
        if (ret == -1 && errno == EAGAIN) { // No more data for now
          return false;
        }
        checkUnixError(ret, "read");
        if (ret == 0) { // Reached end-of-file
          splitter.flush(); // Ignore return since the file is over anyway
          return true;
        }
        if (!splitter(StringPiece(buf, ret))) {
          return true; // The callback told us to stop
        }
      }
    }

Member Data Documentation

template<class Callback >

const uint64_t folly::Subprocess::ReadLinesCallback< Callback >::bufSize_

private

Definition at line 809 of file Subprocess.h.

template<class Callback >

const char folly::Subprocess::ReadLinesCallback< Callback >::delimiter_

private

Definition at line 808 of file Subprocess.h.

template<class Callback >

Callback folly::Subprocess::ReadLinesCallback< Callback >::fdLineCb_

private

Definition at line 806 of file Subprocess.h.

template<class Callback >

std::unordered_map<int, LineSplitter> folly::Subprocess::ReadLinesCallback< Callback >::fdToSplitter_

private

Definition at line 811 of file Subprocess.h.

template<class Callback >

const uint64_t folly::Subprocess::ReadLinesCallback< Callback >::maxLineLength_

private

Definition at line 807 of file Subprocess.h.

---

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

• proxygen/folly/folly/Subprocess.h