all files / lib/ _stream_duplex.js

69.23% Statements 27/39
68.18% Branches 15/22
40% Functions 2/5
75.76% Lines 25/33
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75                  49×               49×     49×       49× 49×     49× 49×   49×   49× 49× 392× 392×     49× 25×   25× 25×   25×   25×   25× 25×   25×       49×     18×             49×       49×        
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.
 
'use strict';
 
/*<replacement>*/
 
var objectKeys = Object.keys || function (obj) {
  var keys = [];
  for (var key in obj) {
    keys.push(key);
  }return keys;
};
/*</replacement>*/
 
module.exports = Duplex;
 
/*<replacement>*/
var processNextTick = require('process-nextick-args');
/*</replacement>*/
 
/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/
 
var Readable = require('./_stream_readable');
var Writable = require('./_stream_writable');
 
util.inherits(Duplex, Readable);
 
var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
  var method = keys[v];
  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
 
function Duplex(options) {
  Iif (!(this instanceof Duplex)) return new Duplex(options);
 
  Readable.call(this, options);
  Writable.call(this, options);
 
  Iif (options && options.readable === false) this.readable = false;
 
  Iif (options && options.writable === false) this.writable = false;
 
  this.allowHalfOpen = true;
  Iif (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
 
  this.once('end', onend);
}
 
// the no-half-open enforcer
function onend() {
  // if we allow half-open state, or if the writable side ended,
  // then we're ok.
  Eif (this.allowHalfOpen || this._writableState.ended) return;
 
  // no more data can be written.
  // But allow more writes to happen in this tick.
  processNextTick(onEndNT, this);
}
 
function onEndNT(self) {
  self.end();
}
 
function forEach(xs, f) {
  for (var i = 0, l = xs.length; i < l; i++) {
    f(xs[i], i);
  }
}