Source: util/dynamic-buffer.js

  1. /**
  2.  * Encapsulate a Buffer and support dynamic reallocation.
  3.  * Copyright (C) 2013-2016 Regents of the University of California.
  4.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU Lesser General Public License as published by
  8.  * the Free Software Foundation, either version 3 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  19.  */
  21. /**
  22.  * Create a DynamicBuffer where this.array is a Buffer of size length.
  23.  * To access the array, use this.array or call slice.
  24.  * @constructor
  25.  * @param {number} length the initial length of the array.  If null, use a default.
  26.  */
  27. var DynamicBuffer = function DynamicBuffer(length)
  28. {
  29.   if (!length)
  30.     length = 16;
  32.   this.array = new Buffer(length);
  33. };
  35. exports.DynamicBuffer = DynamicBuffer;
  37. /**
  38.  * Ensure that this.array has the length, reallocate and copy if necessary.
  39.  * Update the length of this.array which may be greater than length.
  40.  * @param {number} length The minimum length for the array.
  41.  */
  42. DynamicBuffer.prototype.ensureLength = function(length)
  43. {
  44.   if (this.array.length >= length)
  45.     return;
  47.   // See if double is enough.
  48.   var newLength = this.array.length * 2;
  49.   if (length > newLength)
  50.     // The needed length is much greater, so use it.
  51.     newLength = length;
  53.   var newArray = new Buffer(newLength);
  54.   this.array.copy(newArray);
  55.   this.array = newArray;
  56. };
  58. /**
  59.  * Copy the value to this.array at offset, reallocating if necessary.
  60.  * @param {Buffer} value The buffer to copy.
  61.  * @param {number} offset The offset in the buffer to start copying into.
  62.  * @returns {number} The new offset which is offset + value.length.
  63.  */
  64. DynamicBuffer.prototype.copy = function(value, offset)
  65. {
  66.   this.ensureLength(value.length + offset);
  68.   if (Buffer.isBuffer(value))
  69.     value.copy(this.array, offset);
  70.   else
  71.     // Need to make value a Buffer to copy.
  72.     new Buffer(value).copy(this.array, offset);
  74.   return offset + value.length;
  75. };
  77. /**
  78.  * Ensure that this.array has the length. If necessary, reallocate the array
  79.  *   and shift existing data to the back of the new array.
  80.  * Update the length of this.array which may be greater than length.
  81.  * @param {number} length The minimum length for the array.
  82.  */
  83. DynamicBuffer.prototype.ensureLengthFromBack = function(length)
  84. {
  85.   if (this.array.length >= length)
  86.     return;
  88.   // See if double is enough.
  89.   var newLength = this.array.length * 2;
  90.   if (length > newLength)
  91.     // The needed length is much greater, so use it.
  92.     newLength = length;
  94.   var newArray = new Buffer(newLength);
  95.   // Copy to the back of newArray.
  96.   this.array.copy(newArray, newArray.length - this.array.length);
  97.   this.array = newArray;
  98. };
  100. /**
  101.  * First call ensureLengthFromBack to make sure the bytearray has
  102.  * offsetFromBack bytes, then copy value into the array starting
  103.  * offsetFromBack bytes from the back of the array.
  104.  * @param {Buffer} value The buffer to copy.
  105.  * @param {number} offsetFromBack The offset from the back of the array to start
  106.  * copying.
  107.  */
  108. DynamicBuffer.prototype.copyFromBack = function(value, offsetFromBack)
  109. {
  110.   this.ensureLengthFromBack(offsetFromBack);
  112.   if (Buffer.isBuffer(value))
  113.     value.copy(this.array, this.array.length - offsetFromBack);
  114.   else
  115.     // Need to make value a Buffer to copy.
  116.     new Buffer(value).copy(this.array, this.array.length - offsetFromBack);
  117. };
  119. /**
  120.  * Return this.array.slice(begin, end);
  121.  * @param {number} begin The begin index for the slice.
  122.  * @param {number} end (optional) The end index for the slice.
  123.  * @returns {Buffer} The buffer slice.
  124.  */
  125. DynamicBuffer.prototype.slice = function(begin, end)
  126. {
  127.   if (end == undefined)
  128.     return this.array.slice(begin);
  129.   else
  130.     return this.array.slice(begin, end);
  131. };