blob: fec138def214d5c84e7450cdb11392644e04a83e [file] [log] [blame]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/**
* @fileoverview Definition of BinaryWriter.
* @private
*/
module.exports = BinaryWriter;
var INITIAL_SIZE = 64;
/**
* BinaryWriter assists in writing to a Uint8Array by expanding the buffer to
* the necessary size and keeping track of the current write position.
* @private
* @constructor
*/
function BinaryWriter() {
this.allocatedSize = INITIAL_SIZE;
this.pos = 0;
this.buf = new Uint8Array(this.allocatedSize);
}
/**
* Ensures there is enough space for a write of the specified size in the
* backing array.
* This has the side effect of consuming the specified number of bytes from the
* array so that they can no longer be used for future writes.
* @param {number} amt The number of bytes that are needed for the next write.
* @return {number} The position in the backing array to write to.
*/
BinaryWriter.prototype._reserve = function(amt) {
var pos = this.pos;
var amtNeeded = this.pos + amt;
// Expand the buffer as much as necessary.
var expand = getMinPowerOfTwo(this.allocatedSize, amtNeeded);
if (expand > 1) {
this.allocatedSize = this.allocatedSize * expand;
var newBuf = new Uint8Array(this.allocatedSize);
newBuf.set(this.buf);
this.buf = newBuf;
}
this.pos += amt;
return pos;
};
/**
* Writes a byte to the backing Uint8Array.
* @param {number} val The value of the byte to write.
*/
BinaryWriter.prototype.writeByte = function(val) {
var pos = this._reserve(1);
this.buf[pos] = val;
};
/**
* Writes an array of bytes to the backing Uint8Array.
* @param {number} val The byte array to write.
*/
BinaryWriter.prototype.writeByteArray = function(bytes) {
var pos = this._reserve(bytes.length);
this.buf.set(bytes, pos);
};
/**
* Gets a Uint8Array of the written data.
* @param {Uint8Array} The written data.
*/
BinaryWriter.prototype.getBytes = function() {
return this.buf.subarray(0, this.pos);
};
/**
* Gets position of buffer
* @return {number} position of buffer
*/
BinaryWriter.prototype.getPos = function() {
return this.pos;
};
/**
* Seeks back to a previous position
* @param {number} pos the new position.
*/
BinaryWriter.prototype.seekBack = function(pos) {
if (pos > this.pos) {
throw new Error('Cant seek forward');
}
this.pos = pos;
};
/**
* Computes the smallest power of 2 to make current exceed target.
* @private
* @param {number} current, must be positive
* @param {number} target
* @return {number} smallest power of 2, where current * power >= target
*/
function getMinPowerOfTwo(current, target) {
var power = 1;
while (current * power < target) {
power *= 2;
}
return power;
}