• Here's an abbreviated version of the interface file:

class OutboundFile {
 public:
  OutboundFile();
  void initialize(const std::string& source, int sink);
  bool sendMoreData();

 private:
  // implementation details ommitted for the moment
}

• The constructor just defaultly constructs an instance of the OutboundFile class. The initialize method identifies what local file should be used as a source of data and the descriptor where that data should be written verbatim. The sendMoreData method pushes as much data as possible to the supplied sink, without blocking. It returns true if it's at all possible there's more data to be sent, and false if all data has been fully pushed out. The full interface file (which leaks some implementation details, because you see the private section) is right here.

• It's a simple program prints the source of the unit test to standard output. #meta
• There's a copy of the code right here.

/**
 * File: outbound-file-test.cc
 * ---------------------------
 * Demonstrates how one should use the OutboundFile class
 * and can be used to confirm that it works properly.
 */
#include "outbound-file.h"
int main(int argc, char *argv[]) {
  OutboundFile obf;
  obf.initialize("outbound-file-test.cc", STDOUT_FILENO);
  while (obf.sendMoreData()) {;}
  return 0;
}

• This is a program that implements a nonblocking server that happily serves up a copy of the server code itself to the client.
• A full copy of the program is right here.
• And here's a copy of the program right here:

static const unsigned short kDefaultPort = 12345;
static const string kFileToServe("expensive-server.cc");
int main(int argc, char *argv[]) {
  int serverSocket = createServerSocket(kDefaultPort);
  if (serverSocket == kServerSocketFailure) {
    cerr << "Could not start server.  Port " << kDefaultPort << " is probably in use." << endl;
    return 0;
  }

  setAsNonBlocking(serverSocket);
  cout << "Static file server listening on port " << kDefaultPort << "." << endl;
  list<OutboundFile> outboundFiles;
  size_t numConnections = 0;
  size_t numActiveConnections = 0;

  while (true) {
    int clientSocket = accept(serverSocket, NULL, NULL);
    if (clientSocket == -1) {
      assert(errno == EWOULDBLOCK);
    } else {
      OutboundFile obf;
      obf.initialize(kFileToServe, clientSocket);
      outboundFiles.push_back(obf);
      cout << "Connection #" << ++numConnections << endl;
      cout << "Queue size: " << ++numActiveConnections << endl;
    }

    auto iter = outboundFiles.begin();
    while (iter != outboundFiles.end()) {
      if (iter->sendMoreData()) {
        ++iter;
      } else {
        iter = outboundFiles.erase(iter);
        cout << "Queue size: " << --numActiveConnections << endl;
      }
    }
  }
}

• The implementation of setAsNonBlocking is UNIX gobbledygook, and it's right here:

void setAsNonBlocking(int descriptor) {
  int flags = fcntl(descriptor, F_GETFL);
  if (flags == -1) flags = 0; // if first call to fcntl fails, just go with 0 
  fcntl(descriptor, F_SETFL, flags | O_NONBLOCK); // preserve other set flags
}