794 lines
19 KiB
JavaScript
794 lines
19 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.alloc = exports.NodeBuffer = exports.CombinedBuffer = exports.SliceBuffer = exports.HeapBuffer = exports.BaseBuffer = undefined;
|
|
|
|
var _get2 = require("babel-runtime/helpers/get");
|
|
|
|
var _get3 = _interopRequireDefault(_get2);
|
|
|
|
var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");
|
|
|
|
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
|
|
|
|
var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
|
|
|
|
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
|
|
|
|
var _inherits2 = require("babel-runtime/helpers/inherits");
|
|
|
|
var _inherits3 = _interopRequireDefault(_inherits2);
|
|
|
|
var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
|
|
|
|
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
|
|
|
|
var _createClass2 = require("babel-runtime/helpers/createClass");
|
|
|
|
var _createClass3 = _interopRequireDefault(_createClass2);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Copyright (c) 2002-2018 "Neo4j,"
|
|
* Neo4j Sweden AB [http://neo4j.com]
|
|
*
|
|
* This file is part of Neo4j.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/** This module defines a common API for dealing with binary data that
|
|
* works for both browsers (via ArrayBuffer/DataView) and for NodeJS
|
|
*(via Buffer API).
|
|
*/
|
|
|
|
var _node = require("buffer");
|
|
/**
|
|
* Common base with default implementation for most buffer methods.
|
|
* Buffers are stateful - they track a current "position", this helps greatly
|
|
* when reading and writing from them incrementally. You can also ignore the
|
|
* stateful read/write methods.
|
|
* readXXX and writeXXX-methods move the inner position of the buffer.
|
|
* putXXX and getXXX-methods do not.
|
|
* @access private
|
|
*/
|
|
|
|
var BaseBuffer = function () {
|
|
/**
|
|
* Create a instance with the injected size.
|
|
* @constructor
|
|
* @param {Integer} size
|
|
*/
|
|
function BaseBuffer(size) {
|
|
(0, _classCallCheck3.default)(this, BaseBuffer);
|
|
|
|
this.position = 0;
|
|
this.length = size;
|
|
// Calling these out - this is the required
|
|
// methods a subclass needs to implement
|
|
var getUInt8 = null;
|
|
var getInt8 = null;
|
|
var getFloat64 = null;
|
|
var getSlice = null;
|
|
var putFloat64 = null;
|
|
var putUInt8 = null;
|
|
var putInt8 = null;
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
*/
|
|
|
|
|
|
(0, _createClass3.default)(BaseBuffer, [{
|
|
key: "getInt16",
|
|
value: function getInt16(p) {
|
|
return this.getInt8(p) << 8 | this.getUInt8(p + 1);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
*/
|
|
|
|
}, {
|
|
key: "getUInt16",
|
|
value: function getUInt16(p) {
|
|
return this.getUInt8(p) << 8 | this.getUInt8(p + 1);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
*/
|
|
|
|
}, {
|
|
key: "getInt32",
|
|
value: function getInt32(p) {
|
|
return this.getInt8(p) << 24 | this.getUInt8(p + 1) << 16 | this.getUInt8(p + 2) << 8 | this.getUInt8(p + 3);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
*/
|
|
|
|
}, {
|
|
key: "getUInt32",
|
|
value: function getUInt32(p) {
|
|
return this.getUInt8(p) << 24 | this.getUInt8(p + 1) << 16 | this.getUInt8(p + 2) << 8 | this.getUInt8(p + 3);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
*/
|
|
|
|
}, {
|
|
key: "getInt64",
|
|
value: function getInt64(p) {
|
|
return this.getInt8(p) << 56 | this.getUInt8(p + 1) << 48 | this.getUInt8(p + 2) << 40 | this.getUInt8(p + 3) << 32 | this.getUInt8(p + 4) << 24 | this.getUInt8(p + 5) << 16 | this.getUInt8(p + 6) << 8 | this.getUInt8(p + 7);
|
|
}
|
|
|
|
/**
|
|
* Get a slice of this buffer. This method does not copy any data,
|
|
* but simply provides a slice view of this buffer
|
|
* @param start
|
|
* @param length
|
|
*/
|
|
|
|
}, {
|
|
key: "getSlice",
|
|
value: function getSlice(start, length) {
|
|
return new SliceBuffer(start, length, this);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "putInt16",
|
|
value: function putInt16(p, val) {
|
|
this.putInt8(p, val >> 8);
|
|
this.putUInt8(p + 1, val & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "putUInt16",
|
|
value: function putUInt16(p, val) {
|
|
this.putUInt8(p, val >> 8 & 0xFF);
|
|
this.putUInt8(p + 1, val & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "putInt32",
|
|
value: function putInt32(p, val) {
|
|
this.putInt8(p, val >> 24);
|
|
this.putUInt8(p + 1, val >> 16 & 0xFF);
|
|
this.putUInt8(p + 2, val >> 8 & 0xFF);
|
|
this.putUInt8(p + 3, val & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "putUInt32",
|
|
value: function putUInt32(p, val) {
|
|
this.putUInt8(p, val >> 24 & 0xFF);
|
|
this.putUInt8(p + 1, val >> 16 & 0xFF);
|
|
this.putUInt8(p + 2, val >> 8 & 0xFF);
|
|
this.putUInt8(p + 3, val & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @param p
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "putInt64",
|
|
value: function putInt64(p, val) {
|
|
this.putInt8(p, val >> 48);
|
|
this.putUInt8(p + 1, val >> 42 & 0xFF);
|
|
this.putUInt8(p + 2, val >> 36 & 0xFF);
|
|
this.putUInt8(p + 3, val >> 30 & 0xFF);
|
|
this.putUInt8(p + 4, val >> 24 & 0xFF);
|
|
this.putUInt8(p + 5, val >> 16 & 0xFF);
|
|
this.putUInt8(p + 6, val >> 8 & 0xFF);
|
|
this.putUInt8(p + 7, val & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @param position
|
|
* @param other
|
|
*/
|
|
|
|
}, {
|
|
key: "putBytes",
|
|
value: function putBytes(position, other) {
|
|
for (var i = 0, end = other.remaining(); i < end; i++) {
|
|
this.putUInt8(position + i, other.readUInt8());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readUInt8",
|
|
value: function readUInt8() {
|
|
return this.getUInt8(this._updatePos(1));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readInt8",
|
|
value: function readInt8() {
|
|
return this.getInt8(this._updatePos(1));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readUInt16",
|
|
value: function readUInt16() {
|
|
return this.getUInt16(this._updatePos(2));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readUInt32",
|
|
value: function readUInt32() {
|
|
return this.getUInt32(this._updatePos(4));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readInt16",
|
|
value: function readInt16() {
|
|
return this.getInt16(this._updatePos(2));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readInt32",
|
|
value: function readInt32() {
|
|
return this.getInt32(this._updatePos(4));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readInt64",
|
|
value: function readInt64() {
|
|
return this.getInt32(this._updatePos(8));
|
|
}
|
|
|
|
/**
|
|
* Read from state position.
|
|
*/
|
|
|
|
}, {
|
|
key: "readFloat64",
|
|
value: function readFloat64() {
|
|
return this.getFloat64(this._updatePos(8));
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeUInt8",
|
|
value: function writeUInt8(val) {
|
|
this.putUInt8(this._updatePos(1), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeInt8",
|
|
value: function writeInt8(val) {
|
|
this.putInt8(this._updatePos(1), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeInt16",
|
|
value: function writeInt16(val) {
|
|
this.putInt16(this._updatePos(2), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeInt32",
|
|
value: function writeInt32(val) {
|
|
this.putInt32(this._updatePos(4), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeUInt32",
|
|
value: function writeUInt32(val) {
|
|
this.putUInt32(this._updatePos(4), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeInt64",
|
|
value: function writeInt64(val) {
|
|
this.putInt64(this._updatePos(8), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeFloat64",
|
|
value: function writeFloat64(val) {
|
|
this.putFloat64(this._updatePos(8), val);
|
|
}
|
|
|
|
/**
|
|
* Write to state position.
|
|
* @param val
|
|
*/
|
|
|
|
}, {
|
|
key: "writeBytes",
|
|
value: function writeBytes(val) {
|
|
this.putBytes(this._updatePos(val.remaining()), val);
|
|
}
|
|
|
|
/**
|
|
* Get a slice of this buffer. This method does not copy any data,
|
|
* but simply provides a slice view of this buffer
|
|
* @param length
|
|
*/
|
|
|
|
}, {
|
|
key: "readSlice",
|
|
value: function readSlice(length) {
|
|
return this.getSlice(this._updatePos(length), length);
|
|
}
|
|
}, {
|
|
key: "_updatePos",
|
|
value: function _updatePos(length) {
|
|
var p = this.position;
|
|
this.position += length;
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Get remaining
|
|
*/
|
|
|
|
}, {
|
|
key: "remaining",
|
|
value: function remaining() {
|
|
return this.length - this.position;
|
|
}
|
|
|
|
/**
|
|
* Has remaining
|
|
*/
|
|
|
|
}, {
|
|
key: "hasRemaining",
|
|
value: function hasRemaining() {
|
|
return this.remaining() > 0;
|
|
}
|
|
|
|
/**
|
|
* Reset position state
|
|
*/
|
|
|
|
}, {
|
|
key: "reset",
|
|
value: function reset() {
|
|
this.position = 0;
|
|
}
|
|
|
|
/**
|
|
* Get string representation of buffer and it's state.
|
|
* @return {string} Buffer as a string
|
|
*/
|
|
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return this.constructor.name + "( position=" + this.position + " )\n " + this.toHex();
|
|
}
|
|
|
|
/**
|
|
* Get string representation of buffer.
|
|
* @return {string} Buffer as a string
|
|
*/
|
|
|
|
}, {
|
|
key: "toHex",
|
|
value: function toHex() {
|
|
// TODO something like StringBuilder?
|
|
var out = "";
|
|
for (var i = 0; i < this.length; i++) {
|
|
var hexByte = this.getUInt8(i).toString(16);
|
|
if (hexByte.length == 1) {
|
|
hexByte = "0" + hexByte;
|
|
}
|
|
out += hexByte + " ";
|
|
}
|
|
return out;
|
|
}
|
|
}]);
|
|
return BaseBuffer;
|
|
}();
|
|
|
|
/**
|
|
* Basic buffer implementation that should work in most any modern JS env.
|
|
* @access private
|
|
*/
|
|
|
|
|
|
var HeapBuffer = function (_BaseBuffer) {
|
|
(0, _inherits3.default)(HeapBuffer, _BaseBuffer);
|
|
|
|
function HeapBuffer(arg) {
|
|
(0, _classCallCheck3.default)(this, HeapBuffer);
|
|
|
|
var buffer = arg instanceof ArrayBuffer ? arg : new ArrayBuffer(arg);
|
|
|
|
var _this = (0, _possibleConstructorReturn3.default)(this, (HeapBuffer.__proto__ || (0, _getPrototypeOf2.default)(HeapBuffer)).call(this, buffer.byteLength));
|
|
|
|
_this._buffer = buffer;
|
|
_this._view = new DataView(_this._buffer);
|
|
return _this;
|
|
}
|
|
|
|
(0, _createClass3.default)(HeapBuffer, [{
|
|
key: "putUInt8",
|
|
value: function putUInt8(position, val) {
|
|
this._view.setUint8(position, val);
|
|
}
|
|
}, {
|
|
key: "getUInt8",
|
|
value: function getUInt8(position) {
|
|
return this._view.getUint8(position);
|
|
}
|
|
}, {
|
|
key: "putInt8",
|
|
value: function putInt8(position, val) {
|
|
this._view.setInt8(position, val);
|
|
}
|
|
}, {
|
|
key: "getInt8",
|
|
value: function getInt8(position) {
|
|
return this._view.getInt8(position);
|
|
}
|
|
}, {
|
|
key: "getFloat64",
|
|
value: function getFloat64(position) {
|
|
return this._view.getFloat64(position);
|
|
}
|
|
}, {
|
|
key: "putFloat64",
|
|
value: function putFloat64(position, val) {
|
|
this._view.setFloat64(position, val);
|
|
}
|
|
}, {
|
|
key: "getSlice",
|
|
value: function getSlice(start, length) {
|
|
if (this._buffer.slice) {
|
|
return new HeapBuffer(this._buffer.slice(start, start + length));
|
|
} else {
|
|
// Some platforms (eg. phantomjs) don't support slice, so fall back to a copy
|
|
// We do this rather than return a SliceBuffer, because sliceBuffer cannot
|
|
// be passed to native network write ops etc - we need ArrayBuffer for that
|
|
var copy = new HeapBuffer(length);
|
|
for (var i = 0; i < length; i++) {
|
|
copy.putUInt8(i, this.getUInt8(i + start));
|
|
}
|
|
return copy;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Specific to HeapBuffer, this gets a DataView from the
|
|
* current position and of the specified length.
|
|
*/
|
|
|
|
}, {
|
|
key: "readView",
|
|
value: function readView(length) {
|
|
return new DataView(this._buffer, this._updatePos(length), length);
|
|
}
|
|
}]);
|
|
return HeapBuffer;
|
|
}(BaseBuffer);
|
|
|
|
/**
|
|
* Represents a view as slice of another buffer.
|
|
* @access private
|
|
*/
|
|
|
|
|
|
var SliceBuffer = function (_BaseBuffer2) {
|
|
(0, _inherits3.default)(SliceBuffer, _BaseBuffer2);
|
|
|
|
function SliceBuffer(start, length, inner) {
|
|
(0, _classCallCheck3.default)(this, SliceBuffer);
|
|
|
|
var _this2 = (0, _possibleConstructorReturn3.default)(this, (SliceBuffer.__proto__ || (0, _getPrototypeOf2.default)(SliceBuffer)).call(this, length));
|
|
|
|
_this2._start = start;
|
|
_this2._inner = inner;
|
|
return _this2;
|
|
}
|
|
|
|
(0, _createClass3.default)(SliceBuffer, [{
|
|
key: "putUInt8",
|
|
value: function putUInt8(position, val) {
|
|
this._inner.putUInt8(this._start + position, val);
|
|
}
|
|
}, {
|
|
key: "getUInt8",
|
|
value: function getUInt8(position) {
|
|
return this._inner.getUInt8(this._start + position);
|
|
}
|
|
}, {
|
|
key: "putInt8",
|
|
value: function putInt8(position, val) {
|
|
this._inner.putInt8(this._start + position, val);
|
|
}
|
|
}, {
|
|
key: "putFloat64",
|
|
value: function putFloat64(position, val) {
|
|
this._inner.putFloat64(this._start + position, val);
|
|
}
|
|
}, {
|
|
key: "getInt8",
|
|
value: function getInt8(position) {
|
|
return this._inner.getInt8(this._start + position);
|
|
}
|
|
}, {
|
|
key: "getFloat64",
|
|
value: function getFloat64(position) {
|
|
return this._inner.getFloat64(this._start + position);
|
|
}
|
|
}]);
|
|
return SliceBuffer;
|
|
}(BaseBuffer);
|
|
|
|
/**
|
|
* Buffer that combines multiple buffers, exposing them as one single buffer.
|
|
* @access private
|
|
*/
|
|
|
|
|
|
var CombinedBuffer = function (_BaseBuffer3) {
|
|
(0, _inherits3.default)(CombinedBuffer, _BaseBuffer3);
|
|
|
|
function CombinedBuffer(buffers) {
|
|
(0, _classCallCheck3.default)(this, CombinedBuffer);
|
|
|
|
var length = 0;
|
|
for (var i = 0; i < buffers.length; i++) {
|
|
length += buffers[i].length;
|
|
}
|
|
|
|
var _this3 = (0, _possibleConstructorReturn3.default)(this, (CombinedBuffer.__proto__ || (0, _getPrototypeOf2.default)(CombinedBuffer)).call(this, length));
|
|
|
|
_this3._buffers = buffers;
|
|
return _this3;
|
|
}
|
|
|
|
(0, _createClass3.default)(CombinedBuffer, [{
|
|
key: "getUInt8",
|
|
value: function getUInt8(position) {
|
|
// Surely there's a faster way to do this.. some sort of lookup table thing?
|
|
for (var i = 0; i < this._buffers.length; i++) {
|
|
var buffer = this._buffers[i];
|
|
// If the position is not in the current buffer, skip the current buffer
|
|
if (position >= buffer.length) {
|
|
position -= buffer.length;
|
|
} else {
|
|
return buffer.getUInt8(position);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "getInt8",
|
|
value: function getInt8(position) {
|
|
// Surely there's a faster way to do this.. some sort of lookup table thing?
|
|
for (var i = 0; i < this._buffers.length; i++) {
|
|
var buffer = this._buffers[i];
|
|
// If the position is not in the current buffer, skip the current buffer
|
|
if (position >= buffer.length) {
|
|
position -= buffer.length;
|
|
} else {
|
|
return buffer.getInt8(position);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "getFloat64",
|
|
value: function getFloat64(position) {
|
|
// At some point, a more efficient impl. For now, we copy the 8 bytes
|
|
// we want to read and depend on the platform impl of IEEE 754.
|
|
var b = alloc(8);
|
|
for (var i = 0; i < 8; i++) {
|
|
b.putUInt8(i, this.getUInt8(position + i));
|
|
};
|
|
return b.getFloat64(0);
|
|
}
|
|
}]);
|
|
return CombinedBuffer;
|
|
}(BaseBuffer);
|
|
|
|
/**
|
|
* Buffer used in a Node.js environment
|
|
* @access private
|
|
*/
|
|
|
|
|
|
var NodeBuffer = function (_BaseBuffer4) {
|
|
(0, _inherits3.default)(NodeBuffer, _BaseBuffer4);
|
|
|
|
function NodeBuffer(arg) {
|
|
(0, _classCallCheck3.default)(this, NodeBuffer);
|
|
|
|
var buffer = arg instanceof _node.Buffer ? arg : newNodeJSBuffer(arg);
|
|
|
|
var _this4 = (0, _possibleConstructorReturn3.default)(this, (NodeBuffer.__proto__ || (0, _getPrototypeOf2.default)(NodeBuffer)).call(this, buffer.length));
|
|
|
|
_this4._buffer = buffer;
|
|
return _this4;
|
|
}
|
|
|
|
(0, _createClass3.default)(NodeBuffer, [{
|
|
key: "getUInt8",
|
|
value: function getUInt8(position) {
|
|
return this._buffer.readUInt8(position);
|
|
}
|
|
}, {
|
|
key: "getInt8",
|
|
value: function getInt8(position) {
|
|
return this._buffer.readInt8(position);
|
|
}
|
|
}, {
|
|
key: "getFloat64",
|
|
value: function getFloat64(position) {
|
|
return this._buffer.readDoubleBE(position);
|
|
}
|
|
}, {
|
|
key: "putUInt8",
|
|
value: function putUInt8(position, val) {
|
|
this._buffer.writeUInt8(val, position);
|
|
}
|
|
}, {
|
|
key: "putInt8",
|
|
value: function putInt8(position, val) {
|
|
this._buffer.writeInt8(val, position);
|
|
}
|
|
}, {
|
|
key: "putFloat64",
|
|
value: function putFloat64(position, val) {
|
|
this._buffer.writeDoubleBE(val, position);
|
|
}
|
|
}, {
|
|
key: "putBytes",
|
|
value: function putBytes(position, val) {
|
|
if (val instanceof NodeBuffer) {
|
|
var bytesToCopy = Math.min(val.length - val.position, this.length - position);
|
|
val._buffer.copy(this._buffer, position, val.position, val.position + bytesToCopy);
|
|
val.position += bytesToCopy;
|
|
} else {
|
|
(0, _get3.default)(NodeBuffer.prototype.__proto__ || (0, _getPrototypeOf2.default)(NodeBuffer.prototype), "putBytes", this).call(this, position, val);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getSlice",
|
|
value: function getSlice(start, length) {
|
|
return new NodeBuffer(this._buffer.slice(start, start + length));
|
|
}
|
|
}]);
|
|
return NodeBuffer;
|
|
}(BaseBuffer);
|
|
|
|
function newNodeJSBuffer(arg) {
|
|
if (typeof arg === 'number' && typeof _node.Buffer.alloc === 'function') {
|
|
// use static factory function present in newer NodeJS versions to allocate new buffer with specified size
|
|
return _node.Buffer.alloc(arg);
|
|
} else {
|
|
// fallback to the old, potentially deprecated constructor
|
|
return new _node.Buffer(arg);
|
|
}
|
|
}
|
|
|
|
// Use HeapBuffer by default, unless Buffer API is available, see below
|
|
var _DefaultBuffer = HeapBuffer;
|
|
try {
|
|
// This will throw an exception if we're not running on NodeJS or equivalent
|
|
require.resolve("buffer");
|
|
_DefaultBuffer = NodeBuffer;
|
|
} catch (e) {}
|
|
|
|
/**
|
|
* Allocate a new buffer using whatever mechanism is most sensible for the
|
|
* current platform
|
|
* @access private
|
|
* @param {Integer} size
|
|
* @return new buffer
|
|
*/
|
|
function alloc(size) {
|
|
return new _DefaultBuffer(size);
|
|
}
|
|
|
|
exports.BaseBuffer = BaseBuffer;
|
|
exports.HeapBuffer = HeapBuffer;
|
|
exports.SliceBuffer = SliceBuffer;
|
|
exports.CombinedBuffer = CombinedBuffer;
|
|
exports.NodeBuffer = NodeBuffer;
|
|
exports.alloc = alloc; |