smart-buffer is a Buffer wrapper that adds automatic read & write offset tracking, string operations, data insertions, and more.
npm install smart-buffersmart-buffer  
=============
smart-buffer is a Buffer wrapper that adds automatic read & write offset tracking, string operations, data insertions, and more.
Key Features:
* Proxies all of the Buffer write and read functions
* Keeps track of read and write offsets automatically
* Grows the internal Buffer as needed
* Useful string operations. (Null terminating strings)
* Allows for inserting values at specific points in the Buffer
* Built in TypeScript
* Type Definitions Provided
* Browser Support (using Webpack/Browserify)
* Full test coverage
Requirements:
* Node v4.0+ is supported at this time. (Versions prior to 2.0 will work on node 0.10)
* Old constructor patterns have been completely removed. It's now required to use the SmartBuffer.fromXXX() factory constructors.
* rewind(), skip(), moveTo() have been removed. (see offsets)
* Internal private properties are now prefixed with underscores (_)
* All writeXXX() methods that are given an offset will now overwrite data instead of insert. (see write vs insert)
* insertXXX() methods have been added for when you want to insert data at a specific offset (this replaces the old behavior of writeXXX() when an offset was provided)
Legacy documentation for version 3 and prior can be found here.
yarn add smart-buffer
or
npm install smart-buffer
Note: The published NPM package includes the built javascript library.
If you cloned this repo and wish to build the library manually use:
npm run build
``javascript
// Javascript
const SmartBuffer = require('smart-buffer').SmartBuffer;
// Typescript
import { SmartBuffer, SmartBufferOptions} from 'smart-buffer';
`
Building a packet that uses the following protocol specification:
[PacketType:2][PacketLength:2][Data:XX]
To build this packet using the vanilla Buffer class, you would have to count up the length of the data payload beforehand. You would also need to keep track of the current "cursor" position in your Buffer so you write everything in the right places. With smart-buffer you don't have to do either of those things.
`javascript
function createLoginPacket(username, password, age, country) {
const packet = new SmartBuffer();
packet.writeUInt16LE(0x0060); // Some packet type
packet.writeStringNT(username);
packet.writeStringNT(password);
packet.writeUInt8(age);
packet.writeStringNT(country);
packet.insertUInt16LE(packet.length - 2, 2);
return packet.toBuffer();
}
`
With the above function, you now can do this:javascript
const login = createLoginPacket("Josh", "secret123", 22, "United States");
//
`
Notice that the value (1e 00) was inserted at position 2.
Reading back the packet we created above is just as easy:
`javascript
const reader = SmartBuffer.fromBuffer(login);
const logininfo = {
packetType: reader.readUInt16LE(),
packetLength: reader.readUInt16LE(),
username: reader.readStringNT(),
password: reader.readStringNT(),
age: reader.readUInt8(),
country: reader.readStringNT()
};
/*
{
packetType: 96, (0x0060)
packetLength: 30,
username: 'Josh',
password: 'secret123',
age: 22,
country: 'United States'
}
*/
`
SmartBuffer v3:
`javascript
const buff = SmartBuffer.fromBuffer(new Buffer([1,2,3,4,5,6]));
buff.writeInt8(7, 2);
console.log(buff.toBuffer())
//
`
SmartBuffer v4:
`javascript
const buff = SmartBuffer.fromBuffer(new Buffer([1,2,3,4,5,6]));
buff.writeInt8(7, 2);
console.log(buff.toBuffer());
//
`
To insert you instead should use:
`javascript
const buff = SmartBuffer.fromBuffer(new Buffer([1,2,3,4,5,6]));
buff.insertInt8(7, 2);
console.log(buff.toBuffer());
//
`
Note: Insert/Writing to a position beyond the currently tracked internal Buffer will zero pad to your offset.
There are a few different ways to construct a SmartBuffer instance.
`javascript
// Creating SmartBuffer from existing Buffer
const buff = SmartBuffer.fromBuffer(buffer); // Creates instance from buffer. (Uses default utf8 encoding)
const buff = SmartBuffer.fromBuffer(buffer, 'ascii'); // Creates instance from buffer with ascii encoding for strings.
// Creating SmartBuffer with specified internal Buffer size. (Note: this is not a hard cap, the internal buffer will grow as needed).
const buff = SmartBuffer.fromSize(1024); // Creates instance with internal Buffer size of 1024.
const buff = SmartBuffer.fromSize(1024, 'utf8'); // Creates instance with internal Buffer size of 1024, and utf8 encoding for strings.
// Creating SmartBuffer with options object. This one specifies size and encoding.
const buff = SmartBuffer.fromOptions({
size: 1024,
encoding: 'ascii'
});
// Creating SmartBuffer with options object. This one specified an existing Buffer.
const buff = SmartBuffer.fromOptions({
buff: buffer
});
// Creating SmartBuffer from a string.
const buff = SmartBuffer.fromBuffer(Buffer.from('some string', 'utf8'));
// Just want a regular SmartBuffer with all default options?
const buff = new SmartBuffer();
`
Note: SmartBuffer is fully documented with Typescript definitions as well as jsdocs so your favorite editor/IDE will have intellisense.
Table of Contents
1. Constructing
2. Numbers
1. Integers
2. Floating Points
3. Strings
1. Strings
2. Null Terminated Strings
4. Buffers
5. Offsets
6. Other
options` {SmartBufferOptions} An optional options object to construct a SmartBuffer with.Examples:
`javascript
const buff = new SmartBuffer();
const buff = new SmartBuffer({
size: 1024,
encoding: 'ascii'
});
`$3
- buffer` {Buffer} The Buffer instance to wrap.
- `encoding` {string} The string encoding to use. `Default: 'utf8'`Examples:
javascript
const someBuffer = Buffer.from('some string');
const buff = SmartBuffer.fromBuffer(someBuffer); // Defaults to utf8
const buff = SmartBuffer.fromBuffer(someBuffer, 'ascii');
`$3
- size` {number} The size to initialize the internal Buffer.
- `encoding` {string} The string encoding to use. `Default: 'utf8'`Examples:
javascript
const buff = SmartBuffer.fromSize(1024); // Defaults to utf8
const buff = SmartBuffer.fromSize(1024, 'ascii');
`$3
- options` {SmartBufferOptions} The Buffer instance to wrap.`typescript
interface SmartBufferOptions {
encoding?: BufferEncoding; // Defaults to utf8
size?: number; // Defaults to 4096
buff?: Buffer;
}
`Examples:
javascript
const buff = SmartBuffer.fromOptions({
size: 1024
};
const buff = SmartBuffer.fromOptions({
size: 1024,
encoding: 'utf8'
});
const buff = SmartBuffer.fromOptions({
encoding: 'utf8'
});const someBuff = Buffer.from('some string', 'utf8');
const buff = SmartBuffer.fromOptions({
buffer: someBuff,
encoding: 'utf8'
});
`Integers
$3
$3
- offset` {number} Optional position to start reading data from. Default: `Auto managed offset`
- Returns {number}Read a Int8 value.
$3
$3
$3
$3
- offset` {number} Optional position to start reading data from. Default: `Auto managed offset`
- Returns {number}Read a 16 bit integer value.
$3
$3
$3
$3
- offset` {number} Optional position to start reading data from. Default: `Auto managed offset`
- Returns {number}Read a 32 bit integer value.
$3
$3
- value` {number} The value to write.
- `offset` {number} An optional offset to write this value to. Default: `Auto managed offset`
- Returns {this}Write a Int8 value.
$3
$3
- value` {number} The value to insert.
- `offset` {number} The offset to insert this data at.
- Returns {this}Insert a Int8 value.
$3
$3
$3
$3
- `value` {number} The value to write.
- `offset` {number} An optional offset to write this value to. Default: `Auto managed offset`
- Returns {this}Write a 16 bit integer value.
$3
$3
$3
$3
- value` {number} The value to insert.
- `offset` {number} The offset to insert this data at.
- Returns {this}Insert a 16 bit integer value.
$3
$3
$3
$3
- `value` {number} The value to write.
- `offset` {number} An optional offset to write this value to. Default: `Auto managed offset`
- Returns {this}Write a 32 bit integer value.
$3
$3
$3
$3
- value` {number} The value to insert.
- `offset` {number} The offset to insert this data at.
- Returns {this}Insert a 32 bit integer value.
Floating Point Numbers
$3
$3
- `offset` {number} Optional position to start reading data from. Default: `Auto managed offset`
- Returns {number}Read a Float value.
$3
$3
- offset` {number} Optional position to start reading data from. Default: `Auto managed offset`
- Returns {number}Read a Double value.
$3
$3
- value` {number} The value to write.
- `offset` {number} An optional offset to write this value to. Default: `Auto managed offset`
- Returns {this}Write a Float value.
$3
$3
- value` {number} The value to insert.
- `offset` {number} The offset to insert this data at.
- Returns {this}Insert a Float value.
$3
$3
- `value` {number} The value to write.
- `offset` {number} An optional offset to write this value to. Default: `Auto managed offset`
- Returns {this}Write a Double value.
$3
$3
- value` {number} The value to insert.
- `offset` {number} The offset to insert this data at.
- Returns {this}Insert a Double value.
Strings
$3
$3
$3
- `size` {number} The number of bytes to read. Default: `Reads to the end of the Buffer.`
- encoding` {string} The string encoding to use. Default: `utf8`.Read a string value.
Examples:
`javascript
const buff = SmartBuffer.fromBuffer(Buffer.from('hello there', 'utf8'));
buff.readString(); // 'hello there'
buff.readString(2); // 'he'
buff.readString(2, 'utf8'); // 'he'
buff.readString('utf8'); // 'hello there'
`$3
$3
$3
$3
- value` {string} The string value to write.
- `offset` {number} The offset to write this value to. Default: `Auto managed offset`
- encoding` {string} An optional string encoding to use. Default: `utf8`Write a string value.
Examples:
javascript
buff.writeString('hello'); // Auto managed offset
buff.writeString('hello', 2);
buff.writeString('hello', 'utf8') // Auto managed offset
buff.writeString('hello', 2, 'utf8');
`$3
- value` {string} The string value to write.
- `offset` {number} The offset to write this value to.
- `encoding` {string} An optional string encoding to use. Default: `utf8`Insert a string value.
Examples:
javascript
buff.insertString('hello', 2);
buff.insertString('hello', 2, 'utf8');
`Null Terminated Strings
$3
$3
- encoding` {string} The string encoding to use. Default: `utf8`.Read a null terminated string value. (If a null is not found, it will read to the end of the Buffer).
Examples:
`javascript
const buff = SmartBuffer.fromBuffer(Buffer.from('hello\0 there', 'utf8'));
buff.readStringNT(); // 'hello'// If we called this again:
buff.readStringNT(); // ' there'
`$3
$3
$3
$3
- value` {string} The string value to write.
- `offset` {number} The offset to write this value to. Default: `Auto managed offset`
- encoding` {string} An optional string encoding to use. Default: `utf8`Write a null terminated string value.
Examples:
javascript
buff.writeStringNT('hello'); // Auto managed offset
buff.writeStringNT('hello', 2); //
buff.writeStringNT('hello', 'utf8') // Auto managed offset
buff.writeStringNT('hello', 2, 'utf8');
`$3
- value` {string} The string value to write.
- `offset` {number} The offset to write this value to.
- `encoding` {string} An optional string encoding to use. Default: `utf8`Insert a null terminated string value.
Examples:
javascript
buff.insertStringNT('hello', 2);
buff.insertStringNT('hello', 2, 'utf8');
`Buffers
$3
- length` {number} The number of bytes to read into a Buffer. Default: `Reads to the end of the Buffer`Read a Buffer of a specified size.
$3
- value` {Buffer} The buffer value to write.
- `offset` {number} An optional offset to write the value to. Default: `Auto managed offset`$3
- value` {Buffer} The buffer value to write.
- `offset` {number} The offset to write the value to.
$3
Read a null terminated Buffer.
$3
- `value` {Buffer} The buffer value to write.
- `offset` {number} An optional offset to write the value to. Default: `Auto managed offset`Write a null terminated Buffer.
$3
- value` {Buffer} The buffer value to write.
- `offset` {number} The offset to write the value to.Insert a null terminated Buffer.
Offsets
$3
$3
- `offset` {number} The new read offset value to set.
- Returns: `The current read offset`Gets or sets the current read offset.
Examples:
javascript
const currentOffset = buff.readOffset; // 5buff.readOffset = 10;
console.log(buff.readOffset) // 10
`$3
$3
- offset` {number} The new write offset value to set.
- Returns: `The current write offset`Gets or sets the current write offset.
Examples:
javascript
const currentOffset = buff.writeOffset; // 5buff.writeOffset = 10;
console.log(buff.writeOffset) // 10
`$3
$3
- encoding` {string} The new string encoding to set.
- Returns: `The current string encoding`Gets or sets the current string encoding.
Examples:
javascript
const currentEncoding = buff.encoding; // 'utf8'buff.encoding = 'ascii';
console.log(buff.encoding) // 'ascii'
`Other
$3
Clear and resets the SmartBuffer instance.
$3
- Returns Remaining data left to be read`Gets the number of remaining bytes to be read.
$3
- Returns: {Buffer}Gets the internally managed Buffer (Includes unmanaged data).
Examples:
javascript
const buff = SmartBuffer.fromSize(16);
buff.writeString('hello');
console.log(buff.InternalBuffer); //
`$3
- Returns: {Buffer}Gets a sliced Buffer instance of the internally managed Buffer. (Only includes managed data)
Examples:
javascript
const buff = SmartBuffer.fromSize(16);
buff.writeString('hello');
console.log(buff.toBuffer()); //
`$3
- encoding` {string} The string encoding to use when converting to a string. Default: `utf8``Gets a string representation of all data in the SmartBuffer.
Destroys the SmartBuffer instance.
This work is licensed under the MIT license.