/**
 * This class implements a simple server-side interface to the HTTP
 * protocol: by using this class, an application can receive HTTP
 * requests, process them, and return responses. Each instance of
 * this class corresponds to a particular socket used to receive
 * requests. The current implementation is single-threaded and
 * processes one request at a time.
 */
public class Http { ... }

/**
 * Copy a range of bytes from a buffer to an external location.
 *
 * \param offset
 *      Index within the buffer of the first byte to copy.
 * \param length
 *      Number of bytes to copy.
 * \param dest
 *      Where to copy the bytes: must have room for at least
 *      length bytes.
 *
 * \return
 *      The return value is the actual number of bytes copied,
 *      which may be less than length if the requested range of
 *      bytes extends past the end of the buffer. 0 is returned
 *      if there is no overlap between the requested range and
 *      the actual buffer.
 */
uint32_t Buffer::copy(uint32_t offset, uint32_t length, void* dest)

/*
 * This class implements the client side framework for index range
 * lookups. It manages a single LookupIndexKeys RPC and multiple
 * IndexedRead RPCs. Client side just includes "IndexLookup.h" in
 * its header to use IndexLookup class. Several parameters can be
 * set in the config below:
 * - The number of concurrent indexedRead RPCs
 * - The max number of PKHashes a indexedRead RPC can hold at a time
 * - The size of the active PKHashes
 *
 * To use IndexLookup, the client creates an object of this class by
 * providing all necessary information. After construction of
 * IndexLookup, client can call getNext() function to move to next
 * available object. ...
 */

/*
 * This class is used by client applications to make range queries
 * using indexes. Each instance represents a single range query.
 *
 * To start a range query, a client creates an instance of this
 * class. The client can then call getNext() to retrieve the objects
 * in the desired range. For each object returned by getNext(), the
 * caller can invoke getKey(), getKeyLength(), getValue(), and
 * getValueLength() to get information about that object.
 */

/**
 * Check if the next object is RESULT_READY. This function is
 * implemented in a DCFT module, each execution of isReady() tries
 * to make small progress, and getNext() invokes isReady() in a
 * while loop, until isReady() returns true.
 *
 * isReady() is implemented in a rule-based approach. We check
 * different rules by following a particular order, and perform
 * certain actions if some rule is satisfied.
 *
 * \return
 *      True means the next Object is available. Otherwise, return
 *      false.
 */
bool IndexLookup::isReady() { ... }

/*
 * Indicates whether an indexed read has made enough progress for
 * getNext to return immediately without blocking. In addition, this
 * method does most of the real work for indexed reads, so it must
 * be invoked (either directly, or indirectly by calling getNext) in
 * order for the indexed read to make progress.
 *
 * \return
 *      True means that the next invocation of getNext will not block
 *      (at least one object is available to return, or the end of the
 *      lookup has been reached); false means getNext may block.
 */