@nraynaud/xo-vmdk-to-vhd/dist/virtual-buffer.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.VirtualBuffer = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _pipette = require('pipette');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var chunkSize = 1024 * 1024;

var VirtualBuffer = exports.VirtualBuffer = function () {
  function VirtualBuffer(readStream) {
    (0, _classCallCheck3.default)(this, VirtualBuffer);

    this.slicer = new _pipette.Slicer(readStream);
    this.position = 0;
    this.promise = null;
  }

  (0, _createClass3.default)(VirtualBuffer, [{
    key: 'readChunk',


    // length = -1 means 'until the end'
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(length, label) {
        var _this2 = this;

        var _this, chunks, error, res;

        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _this = this;

                if (!(this.promise !== null)) {
                  _context.next = 3;
                  break;
                }

                throw new Error('pomise already there !!!', this.promise);

              case 3:
                if (!(length === -1)) {
                  _context.next = 15;
                  break;
                }

                chunks = [];
                error = false;

              case 6:
                _context.next = 8;
                return new _promise2.default(function (resolve, reject) {
                  _this2.slicer.read(chunkSize, function (error, length, data, offset) {
                    if (error !== false && error !== true) {
                      reject(error);
                    } else {
                      resolve({ error: error, data: data });
                    }
                  });
                });

              case 8:
                res = _context.sent;

                error = res.error;
                chunks.push(res.data);

              case 11:
                if (error === false) {
                  _context.next = 6;
                  break;
                }

              case 12:
                return _context.abrupt('return', Buffer.concat(chunks));

              case 15:
                this.promise = label;
                return _context.abrupt('return', new _promise2.default(function (resolve, reject) {
                  _this2.slicer.read(length, function (error, actualLength, data, offset) {
                    if (error !== false && error !== true) {
                      _this.promise = null;
                      reject(error);
                    } else {
                      _this.promise = null;
                      _this.position += data.length;
                      resolve(data);
                    }
                  });
                }));

              case 17:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function readChunk(_x, _x2) {
        return _ref.apply(this, arguments);
      }

      return readChunk;
    }()
  }, {
    key: 'isDepleted',
    get: function get() {
      return !this.slicer.readable;
    }
  }]);
  return VirtualBuffer;
}();
//# sourceMappingURL=virtual-buffer.js.map