stream: add Readable.readv

A faster alternative to Readable.read for certain use cases.

e.g.

fs.writevSync(fd, readable.readv())

Author: ronag

lib/internal/streams/readable.js

@@ -641,6 +641,74 @@ function howMuchToRead(n, state) {
   return (state[kState] & kEnded) !== 0 ? state.length : 0;
 }
 
+
+Readable.prototype.readv = function () {
+  const state = this._readableState;
+
+  state[kState] &= ~kEmittedReadable;
+
+  // if we need a readable event, then we need to do some reading.
+  let doRead = (state[kState] & kNeedReadable) !== 0;
+
+  // If we currently have less than the highWaterMark, then also read some.
+  if (state.length === 0 || state.length - n < state.highWaterMark) {
+    doRead = true;
+  }
+
+  // However, if we've ended, then there's no point, if we're already
+  // reading, then it's unnecessary, if we're constructing we have to wait,
+  // and if we're destroyed or errored, then it's not allowed,
+  if ((state[kState] & (kReading | kEnded | kDestroyed | kErrored | kConstructed)) !== kConstructed) {
+    doRead = false;
+  } else if (doRead) {
+    state[kState] |= kReading | kSync;
+    // If the length is currently zero, then we *need* a readable event.
+    if (state.length === 0)
+      state[kState] |= kNeedReadable;
+
+    // Call internal read method
+    try {
+      this._read(state.highWaterMark);
+    } catch (err) {
+      errorOrDestroy(this, err);
+    }
+    state[kState] &= ~kSync;
+  }
+
+  let ret = state.buffer;
+  const ret = state.buffer.splice(state.bufferIndex);
+  state.bufferIndex = 0;
+  state.length = 0;
+
+  if (ret.length === 0) {
+    state[kState] |= state.length <= state.highWaterMark ? kNeedReadable : 0;
+  } else if ((state[kState] & kMultiAwaitDrain) !== 0) {
+    state.awaitDrainWriters.clear();
+  } else {
+    state.awaitDrainWriters = null;
+  }
+
+  if (state.length === 0) {
+    // If we have nothing in the buffer, then we want to know
+    // as soon as we *do* get something into the buffer.
+    if ((state[kState] & kEnded) === 0)
+      state[kState] |= kNeedReadable;
+
+    // If we tried to read() past the EOF, then emit end on the next tick.
+    if ((state[kState] & kEnded) !== 0)
+      endReadable(this);
+  }
+
+  if (ret !== null && (state[kState] & (kErrorEmitted | kCloseEmitted)) === 0) {
+    state[kState] |= kDataEmitted;
+    for (let n = 0; n < ret.length; n++) {
+      this.emit('data', ret[n]);
+    }
+  }
+
+  return ret;
+};
+
 // You can override either this method, or the async _read(n) below.
 Readable.prototype.read = function(n) {
   debug('read', n);