Current File : //usr/lib/node_modules/npm/node_modules/smart-buffer/build/smartbuffer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("./utils");
// The default Buffer size if one is not provided.
const DEFAULT_SMARTBUFFER_SIZE = 4096;
// The default string encoding to use for reading/writing strings.
const DEFAULT_SMARTBUFFER_ENCODING = 'utf8';
class SmartBuffer {
/**
* Creates a new SmartBuffer instance.
*
* @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance.
*/
constructor(options) {
this.length = 0;
this._encoding = DEFAULT_SMARTBUFFER_ENCODING;
this._writeOffset = 0;
this._readOffset = 0;
if (SmartBuffer.isSmartBufferOptions(options)) {
// Checks for encoding
if (options.encoding) {
utils_1.checkEncoding(options.encoding);
this._encoding = options.encoding;
}
// Checks for initial size length
if (options.size) {
if (utils_1.isFiniteInteger(options.size) && options.size > 0) {
this._buff = Buffer.allocUnsafe(options.size);
}
else {
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);
}
// Check for initial Buffer
}
else if (options.buff) {
if (options.buff instanceof Buffer) {
this._buff = options.buff;
this.length = options.buff.length;
}
else {
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);
}
}
else {
this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
}
}
else {
// If something was passed but it's not a SmartBufferOptions object
if (typeof options !== 'undefined') {
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);
}
// Otherwise default to sane options
this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
}
}
/**
* Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding.
*
* @param size { Number } The size of the internal Buffer.
* @param encoding { String } The BufferEncoding to use for strings.
*
* @return { SmartBuffer }
*/
static fromSize(size, encoding) {
return new this({
size: size,
encoding: encoding
});
}
/**
* Creates a new SmartBuffer instance with the provided Buffer and optional encoding.
*
* @param buffer { Buffer } The Buffer to use as the internal Buffer value.
* @param encoding { String } The BufferEncoding to use for strings.
*
* @return { SmartBuffer }
*/
static fromBuffer(buff, encoding) {
return new this({
buff: buff,
encoding: encoding
});
}
/**
* Creates a new SmartBuffer instance with the provided SmartBufferOptions options.
*
* @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance.
*/
static fromOptions(options) {
return new this(options);
}
/**
* Type checking function that determines if an object is a SmartBufferOptions object.
*/
static isSmartBufferOptions(options) {
const castOptions = options;
return (castOptions &&
(castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined));
}
// Signed integers
/**
* Reads an Int8 value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readInt8(offset) {
return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);
}
/**
* Reads an Int16BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readInt16BE(offset) {
return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);
}
/**
* Reads an Int16LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readInt16LE(offset) {
return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);
}
/**
* Reads an Int32BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readInt32BE(offset) {
return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);
}
/**
* Reads an Int32LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readInt32LE(offset) {
return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);
}
/**
* Reads a BigInt64BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { BigInt }
*/
readBigInt64BE(offset) {
utils_1.bigIntAndBufferInt64Check('readBigInt64BE');
return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);
}
/**
* Reads a BigInt64LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { BigInt }
*/
readBigInt64LE(offset) {
utils_1.bigIntAndBufferInt64Check('readBigInt64LE');
return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);
}
/**
* Writes an Int8 value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeInt8(value, offset) {
this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
return this;
}
/**
* Inserts an Int8 value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertInt8(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
}
/**
* Writes an Int16BE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeInt16BE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
}
/**
* Inserts an Int16BE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertInt16BE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
}
/**
* Writes an Int16LE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeInt16LE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
}
/**
* Inserts an Int16LE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertInt16LE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
}
/**
* Writes an Int32BE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeInt32BE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
}
/**
* Inserts an Int32BE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertInt32BE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
}
/**
* Writes an Int32LE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeInt32LE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
}
/**
* Inserts an Int32LE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertInt32LE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
}
/**
* Writes a BigInt64BE value to the current write position (or at optional offset).
*
* @param value { BigInt } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeBigInt64BE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
}
/**
* Inserts a BigInt64BE value at the given offset value.
*
* @param value { BigInt } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertBigInt64BE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
}
/**
* Writes a BigInt64LE value to the current write position (or at optional offset).
*
* @param value { BigInt } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeBigInt64LE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
}
/**
* Inserts a Int64LE value at the given offset value.
*
* @param value { BigInt } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertBigInt64LE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
}
// Unsigned Integers
/**
* Reads an UInt8 value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readUInt8(offset) {
return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);
}
/**
* Reads an UInt16BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readUInt16BE(offset) {
return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);
}
/**
* Reads an UInt16LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readUInt16LE(offset) {
return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);
}
/**
* Reads an UInt32BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readUInt32BE(offset) {
return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);
}
/**
* Reads an UInt32LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readUInt32LE(offset) {
return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);
}
/**
* Reads a BigUInt64BE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { BigInt }
*/
readBigUInt64BE(offset) {
utils_1.bigIntAndBufferInt64Check('readBigUInt64BE');
return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);
}
/**
* Reads a BigUInt64LE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { BigInt }
*/
readBigUInt64LE(offset) {
utils_1.bigIntAndBufferInt64Check('readBigUInt64LE');
return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);
}
/**
* Writes an UInt8 value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeUInt8(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
}
/**
* Inserts an UInt8 value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertUInt8(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
}
/**
* Writes an UInt16BE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeUInt16BE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
}
/**
* Inserts an UInt16BE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertUInt16BE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
}
/**
* Writes an UInt16LE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeUInt16LE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
}
/**
* Inserts an UInt16LE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertUInt16LE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
}
/**
* Writes an UInt32BE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeUInt32BE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
}
/**
* Inserts an UInt32BE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertUInt32BE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
}
/**
* Writes an UInt32LE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeUInt32LE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
}
/**
* Inserts an UInt32LE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertUInt32LE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
}
/**
* Writes a BigUInt64BE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeBigUInt64BE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
}
/**
* Inserts a BigUInt64BE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertBigUInt64BE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
}
/**
* Writes a BigUInt64LE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeBigUInt64LE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
}
/**
* Inserts a BigUInt64LE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertBigUInt64LE(value, offset) {
utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
}
// Floating Point
/**
* Reads an FloatBE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readFloatBE(offset) {
return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);
}
/**
* Reads an FloatLE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readFloatLE(offset) {
return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);
}
/**
* Writes a FloatBE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeFloatBE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
}
/**
* Inserts a FloatBE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertFloatBE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
}
/**
* Writes a FloatLE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeFloatLE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
}
/**
* Inserts a FloatLE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertFloatLE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
}
// Double Floating Point
/**
* Reads an DoublEBE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readDoubleBE(offset) {
return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);
}
/**
* Reads an DoubleLE value from the current read position or an optionally provided offset.
*
* @param offset { Number } The offset to read data from (optional)
* @return { Number }
*/
readDoubleLE(offset) {
return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);
}
/**
* Writes a DoubleBE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeDoubleBE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
}
/**
* Inserts a DoubleBE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertDoubleBE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
}
/**
* Writes a DoubleLE value to the current write position (or at optional offset).
*
* @param value { Number } The value to write.
* @param offset { Number } The offset to write the value at.
*
* @return this
*/
writeDoubleLE(value, offset) {
return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
}
/**
* Inserts a DoubleLE value at the given offset value.
*
* @param value { Number } The value to insert.
* @param offset { Number } The offset to insert the value at.
*
* @return this
*/
insertDoubleLE(value, offset) {
return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
}
// Strings
/**
* Reads a String from the current read position.
*
* @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for
* the string (Defaults to instance level encoding).
* @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).
*
* @return { String }
*/
readString(arg1, encoding) {
let lengthVal;
// Length provided
if (typeof arg1 === 'number') {
utils_1.checkLengthValue(arg1);
lengthVal = Math.min(arg1, this.length - this._readOffset);
}
else {
encoding = arg1;
lengthVal = this.length - this._readOffset;
}
// Check encoding
if (typeof encoding !== 'undefined') {
utils_1.checkEncoding(encoding);
}
const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);
this._readOffset += lengthVal;
return value;
}
/**
* Inserts a String
*
* @param value { String } The String value to insert.
* @param offset { Number } The offset to insert the string at.
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
*
* @return this
*/
insertString(value, offset, encoding) {
utils_1.checkOffsetValue(offset);
return this._handleString(value, true, offset, encoding);
}
/**
* Writes a String
*
* @param value { String } The String value to write.
* @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use.
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
*
* @return this
*/
writeString(value, arg2, encoding) {
return this._handleString(value, false, arg2, encoding);
}
/**
* Reads a null-terminated String from the current read position.
*
* @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).
*
* @return { String }
*/
readStringNT(encoding) {
if (typeof encoding !== 'undefined') {
utils_1.checkEncoding(encoding);
}
// Set null character position to the end SmartBuffer instance.
let nullPos = this.length;
// Find next null character (if one is not found, default from above is used)
for (let i = this._readOffset; i < this.length; i++) {
if (this._buff[i] === 0x00) {
nullPos = i;
break;
}
}
// Read string value
const value = this._buff.slice(this._readOffset, nullPos);
// Increment internal Buffer read offset
this._readOffset = nullPos + 1;
return value.toString(encoding || this._encoding);
}
/**
* Inserts a null-terminated String.
*
* @param value { String } The String value to write.
* @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
*
* @return this
*/
insertStringNT(value, offset, encoding) {
utils_1.checkOffsetValue(offset);
// Write Values
this.insertString(value, offset, encoding);
this.insertUInt8(0x00, offset + value.length);
return this;
}
/**
* Writes a null-terminated String.
*
* @param value { String } The String value to write.
* @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
*
* @return this
*/
writeStringNT(value, arg2, encoding) {
// Write Values
this.writeString(value, arg2, encoding);
this.writeUInt8(0x00, typeof arg2 === 'number' ? arg2 + value.length : this.writeOffset);
return this;
}
// Buffers
/**
* Reads a Buffer from the internal read position.
*
* @param length { Number } The length of data to read as a Buffer.
*
* @return { Buffer }
*/
readBuffer(length) {
if (typeof length !== 'undefined') {
utils_1.checkLengthValue(length);
}
const lengthVal = typeof length === 'number' ? length : this.length;
const endPoint = Math.min(this.length, this._readOffset + lengthVal);
// Read buffer value
const value = this._buff.slice(this._readOffset, endPoint);
// Increment internal Buffer read offset
this._readOffset = endPoint;
return value;
}
/**
* Writes a Buffer to the current write position.
*
* @param value { Buffer } The Buffer to write.
* @param offset { Number } The offset to write the Buffer to.
*
* @return this
*/
insertBuffer(value, offset) {
utils_1.checkOffsetValue(offset);
return this._handleBuffer(value, true, offset);
}
/**
* Writes a Buffer to the current write position.
*
* @param value { Buffer } The Buffer to write.
* @param offset { Number } The offset to write the Buffer to.
*
* @return this
*/
writeBuffer(value, offset) {
return this._handleBuffer(value, false, offset);
}
/**
* Reads a null-terminated Buffer from the current read poisiton.
*
* @return { Buffer }
*/
readBufferNT() {
// Set null character position to the end SmartBuffer instance.
let nullPos = this.length;
// Find next null character (if one is not found, default from above is used)
for (let i = this._readOffset; i < this.length; i++) {
if (this._buff[i] === 0x00) {
nullPos = i;
break;
}
}
// Read value
const value = this._buff.slice(this._readOffset, nullPos);
// Increment internal Buffer read offset
this._readOffset = nullPos + 1;
return value;
}
/**
* Inserts a null-terminated Buffer.
*
* @param value { Buffer } The Buffer to write.
* @param offset { Number } The offset to write the Buffer to.
*
* @return this
*/
insertBufferNT(value, offset) {
utils_1.checkOffsetValue(offset);
// Write Values
this.insertBuffer(value, offset);
this.insertUInt8(0x00, offset + value.length);
return this;
}
/**
* Writes a null-terminated Buffer.
*
* @param value { Buffer } The Buffer to write.
* @param offset { Number } The offset to write the Buffer to.
*
* @return this
*/
writeBufferNT(value, offset) {
// Checks for valid numberic value;
if (typeof offset !== 'undefined') {
utils_1.checkOffsetValue(offset);
}
// Write Values
this.writeBuffer(value, offset);
this.writeUInt8(0x00, typeof offset === 'number' ? offset + value.length : this._writeOffset);
return this;
}
/**
* Clears the SmartBuffer instance to its original empty state.
*/
clear() {
this._writeOffset = 0;
this._readOffset = 0;
this.length = 0;
return this;
}
/**
* Gets the remaining data left to be read from the SmartBuffer instance.
*
* @return { Number }
*/
remaining() {
return this.length - this._readOffset;
}
/**
* Gets the current read offset value of the SmartBuffer instance.
*
* @return { Number }
*/
get readOffset() {
return this._readOffset;
}
/**
* Sets the read offset value of the SmartBuffer instance.
*
* @param offset { Number } - The offset value to set.
*/
set readOffset(offset) {
utils_1.checkOffsetValue(offset);
// Check for bounds.
utils_1.checkTargetOffset(offset, this);
this._readOffset = offset;
}
/**
* Gets the current write offset value of the SmartBuffer instance.
*
* @return { Number }
*/
get writeOffset() {
return this._writeOffset;
}
/**
* Sets the write offset value of the SmartBuffer instance.
*
* @param offset { Number } - The offset value to set.
*/
set writeOffset(offset) {
utils_1.checkOffsetValue(offset);
// Check for bounds.
utils_1.checkTargetOffset(offset, this);
this._writeOffset = offset;
}
/**
* Gets the currently set string encoding of the SmartBuffer instance.
*
* @return { BufferEncoding } The string Buffer encoding currently set.
*/
get encoding() {
return this._encoding;
}
/**
* Sets the string encoding of the SmartBuffer instance.
*
* @param encoding { BufferEncoding } The string Buffer encoding to set.
*/
set encoding(encoding) {
utils_1.checkEncoding(encoding);
this._encoding = encoding;
}
/**
* Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer)
*
* @return { Buffer } The Buffer value.
*/
get internalBuffer() {
return this._buff;
}
/**
* Gets the value of the internal managed Buffer (Includes managed data only)
*
* @param { Buffer }
*/
toBuffer() {
return this._buff.slice(0, this.length);
}
/**
* Gets the String value of the internal managed Buffer
*
* @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding).
*/
toString(encoding) {
const encodingVal = typeof encoding === 'string' ? encoding : this._encoding;
// Check for invalid encoding.
utils_1.checkEncoding(encodingVal);
return this._buff.toString(encodingVal, 0, this.length);
}
/**
* Destroys the SmartBuffer instance.
*/
destroy() {
this.clear();
return this;
}
/**
* Handles inserting and writing strings.
*
* @param value { String } The String value to insert.
* @param isInsert { Boolean } True if inserting a string, false if writing.
* @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use.
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
*/
_handleString(value, isInsert, arg3, encoding) {
let offsetVal = this._writeOffset;
let encodingVal = this._encoding;
// Check for offset
if (typeof arg3 === 'number') {
offsetVal = arg3;
// Check for encoding
}
else if (typeof arg3 === 'string') {
utils_1.checkEncoding(arg3);
encodingVal = arg3;
}
// Check for encoding (third param)
if (typeof encoding === 'string') {
utils_1.checkEncoding(encoding);
encodingVal = encoding;
}
// Calculate bytelength of string.
const byteLength = Buffer.byteLength(value, encodingVal);
// Ensure there is enough internal Buffer capacity.
if (isInsert) {
this.ensureInsertable(byteLength, offsetVal);
}
else {
this._ensureWriteable(byteLength, offsetVal);
}
// Write value
this._buff.write(value, offsetVal, byteLength, encodingVal);
// Increment internal Buffer write offset;
if (isInsert) {
this._writeOffset += byteLength;
}
else {
// If an offset was given, check to see if we wrote beyond the current writeOffset.
if (typeof arg3 === 'number') {
this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength);
}
else {
// If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
this._writeOffset += byteLength;
}
}
return this;
}
/**
* Handles writing or insert of a Buffer.
*
* @param value { Buffer } The Buffer to write.
* @param offset { Number } The offset to write the Buffer to.
*/
_handleBuffer(value, isInsert, offset) {
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
// Ensure there is enough internal Buffer capacity.
if (isInsert) {
this.ensureInsertable(value.length, offsetVal);
}
else {
this._ensureWriteable(value.length, offsetVal);
}
// Write buffer value
value.copy(this._buff, offsetVal);
// Increment internal Buffer write offset;
if (isInsert) {
this._writeOffset += value.length;
}
else {
// If an offset was given, check to see if we wrote beyond the current writeOffset.
if (typeof offset === 'number') {
this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length);
}
else {
// If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
this._writeOffset += value.length;
}
}
return this;
}
/**
* Ensures that the internal Buffer is large enough to read data.
*
* @param length { Number } The length of the data that needs to be read.
* @param offset { Number } The offset of the data that needs to be read.
*/
ensureReadable(length, offset) {
// Offset value defaults to managed read offset.
let offsetVal = this._readOffset;
// If an offset was provided, use it.
if (typeof offset !== 'undefined') {
// Checks for valid numberic value;
utils_1.checkOffsetValue(offset);
// Overide with custom offset.
offsetVal = offset;
}
// Checks if offset is below zero, or the offset+length offset is beyond the total length of the managed data.
if (offsetVal < 0 || offsetVal + length > this.length) {
throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS);
}
}
/**
* Ensures that the internal Buffer is large enough to insert data.
*
* @param dataLength { Number } The length of the data that needs to be written.
* @param offset { Number } The offset of the data to be written.
*/
ensureInsertable(dataLength, offset) {
// Checks for valid numberic value;
utils_1.checkOffsetValue(offset);
// Ensure there is enough internal Buffer capacity.
this._ensureCapacity(this.length + dataLength);
// If an offset was provided and its not the very end of the buffer, copy data into appropriate location in regards to the offset.
if (offset < this.length) {
this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length);
}
// Adjust tracked smart buffer length
if (offset + dataLength > this.length) {
this.length = offset + dataLength;
}
else {
this.length += dataLength;
}
}
/**
* Ensures that the internal Buffer is large enough to write data.
*
* @param dataLength { Number } The length of the data that needs to be written.
* @param offset { Number } The offset of the data to be written (defaults to writeOffset).
*/
_ensureWriteable(dataLength, offset) {
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
// Ensure enough capacity to write data.
this._ensureCapacity(offsetVal + dataLength);
// Adjust SmartBuffer length (if offset + length is larger than managed length, adjust length)
if (offsetVal + dataLength > this.length) {
this.length = offsetVal + dataLength;
}
}
/**
* Ensures that the internal Buffer is large enough to write at least the given amount of data.
*
* @param minLength { Number } The minimum length of the data needs to be written.
*/
_ensureCapacity(minLength) {
const oldLength = this._buff.length;
if (minLength > oldLength) {
let data = this._buff;
let newLength = (oldLength * 3) / 2 + 1;
if (newLength < minLength) {
newLength = minLength;
}
this._buff = Buffer.allocUnsafe(newLength);
data.copy(this._buff, 0, 0, oldLength);
}
}
/**
* Reads a numeric number value using the provided function.
*
* @typeparam T { number | bigint } The type of the value to be read
*
* @param func { Function(offset: number) => number } The function to read data on the internal Buffer with.
* @param byteSize { Number } The number of bytes read.
* @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead.
*
* @returns { T } the number value
*/
_readNumberValue(func, byteSize, offset) {
this.ensureReadable(byteSize, offset);
// Call Buffer.readXXXX();
const value = func.call(this._buff, typeof offset === 'number' ? offset : this._readOffset);
// Adjust internal read offset if an optional read offset was not provided.
if (typeof offset === 'undefined') {
this._readOffset += byteSize;
}
return value;
}
/**
* Inserts a numeric number value based on the given offset and value.
*
* @typeparam T { number | bigint } The type of the value to be written
*
* @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
* @param byteSize { Number } The number of bytes written.
* @param value { T } The number value to write.
* @param offset { Number } the offset to write the number at (REQUIRED).
*
* @returns SmartBuffer this buffer
*/
_insertNumberValue(func, byteSize, value, offset) {
// Check for invalid offset values.
utils_1.checkOffsetValue(offset);
// Ensure there is enough internal Buffer capacity. (raw offset is passed)
this.ensureInsertable(byteSize, offset);
// Call buffer.writeXXXX();
func.call(this._buff, value, offset);
// Adjusts internally managed write offset.
this._writeOffset += byteSize;
return this;
}
/**
* Writes a numeric number value based on the given offset and value.
*
* @typeparam T { number | bigint } The type of the value to be written
*
* @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
* @param byteSize { Number } The number of bytes written.
* @param value { T } The number value to write.
* @param offset { Number } the offset to write the number at (REQUIRED).
*
* @returns SmartBuffer this buffer
*/
_writeNumberValue(func, byteSize, value, offset) {
// If an offset was provided, validate it.
if (typeof offset === 'number') {
// Check if we're writing beyond the bounds of the managed data.
if (offset < 0) {
throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS);
}
utils_1.checkOffsetValue(offset);
}
// Default to writeOffset if no offset value was given.
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
// Ensure there is enough internal Buffer capacity. (raw offset is passed)
this._ensureWriteable(byteSize, offsetVal);
func.call(this._buff, value, offsetVal);
// If an offset was given, check to see if we wrote beyond the current writeOffset.
if (typeof offset === 'number') {
this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize);
}
else {
// If no numeric offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
this._writeOffset += byteSize;
}
return this;
}
}
exports.SmartBuffer = SmartBuffer;
//# sourceMappingURL=smartbuffer.js.map
Mini Shell