Add readSkip and writeSkip methods

README.md

@@ -564,6 +564,38 @@ buff.writeOffset = 10;
 console.log(buff.writeOffset) // 10
 ```
 
+### buff.readSkip(length)
+- ```length``` *{number}* The length of data to skip.
+
+Skips reading for a specified `length` from the current read offset.
+
+This method is just sugar for incrementing the read offset in a chainable way.
+
+Examples:
+```javascript
+buff.readOffset = 5;
+
+buff.readSkip(10).readString(4);
+
+console.log(buff.readOffset) // 19
+```
+
+### buff.writeSkip(length)
+- ```length``` *{number}* The length of data to skip.
+
+Skips writing for a specified `length` from the current write offset. The buffer will be zero-padded for the skipped range.
+
+This method is just sugar for incrementing the write offset in a chainable way.
+
+Examples:
+```javascript
+buff.writeOffset = 5;
+
+buff.writeSkip(10).writeString('cool');
+
+console.log(buff.writeOffset) // 19
+```
+
 ### buff.encoding
 ### buff.encoding(encoding)
 - ```encoding``` *{string}* The new string encoding to set.

src/smartbuffer.ts

@@ -998,6 +998,37 @@ class SmartBuffer {
     return this;
   }
 
+  /**
+   * Skips reading for a specified `length` from the current read position.
+   *
+   * This method is just sugar for incrementing the read offset in a chainable way.
+   *
+   * @param length { Number } The length of data to skip.
+   *
+   * @return this
+   */
+  readSkip(length: number): SmartBuffer {
+    checkLengthValue(length);
+    this.readOffset += length;
+    return this;
+  }
+
+  /**
+   * Skips writing for a specified `length` from the current write position.
+   * The buffer will be zero-padded for the skipped range.
+   *
+   * This method is just sugar for incrementing the write offset in a chainable way.
+   *
+   * @param length { Number } The length of data to skip.
+   *
+   * @return this
+   */
+  writeSkip(length: number): SmartBuffer {
+    checkLengthValue(length);
+    this.writeBuffer(Buffer.alloc(length));
+    return this;
+  }
+
   /**
    * Clears the SmartBuffer instance to its original empty state.
    */

test/smartbuffer.test.ts

@@ -614,26 +614,44 @@ describe('Reading/Writing To/From SmartBuffer', () => {
 });
 
 describe('Skipping around data', () => {
-  let writer = new SmartBuffer();
-  writer.writeStringNT('hello');
-  writer.writeUInt16LE(6699);
-  writer.writeStringNT('world!');
+  it('Should skip writing for a given length', () => {
+    const skipLength = 4;
 
-  it('Should equal the UInt16 that was written above', () => {
-    let reader = SmartBuffer.fromBuffer(writer.toBuffer());
-    reader.readOffset += 6;
-    assert.strictEqual(reader.readUInt16LE(), 6699);
-    reader.readOffset = 0;
-    assert.strictEqual(reader.readStringNT(), 'hello');
-    reader.readOffset -= 6;
+    const writer = new SmartBuffer();
+    writer.writeStringNT('hello');
+    assert.strictEqual(writer.writeOffset, 6);
+    writer.writeSkip(skipLength);
+    assert.strictEqual(writer.writeOffset, 6 + skipLength);
+
+    const reader = SmartBuffer.fromBuffer(writer.toBuffer());
     assert.strictEqual(reader.readStringNT(), 'hello');
+    assert.deepEqual(reader.readBuffer(skipLength), Buffer.alloc(skipLength));
+
+    assert.throws(() => {
+      writer.writeSkip(-1);
+    });
   });
 
-  it('Should throw an error when attempting to skip more bytes than actually exist.', () => {
-    let reader = SmartBuffer.fromBuffer(writer.toBuffer());
+  it('Should skip reading for a given length', () => {
+    const skipLength = 4;
+
+    const writer = new SmartBuffer();
+    writer.writeStringNT('hello');
+    writer.writeStringNT('world!');
+
+    const reader = SmartBuffer.fromBuffer(writer.toBuffer());
+    assert.strictEqual(reader.readStringNT(), 'hello');
+    assert.strictEqual(reader.readOffset, 6);
+    reader.readSkip(skipLength);
+    assert.strictEqual(reader.readOffset, 6 + skipLength);
+    assert.strictEqual(reader.readStringNT(), 'd!');
 
     assert.throws(() => {
-      reader.readOffset = 10000;
+      reader.readSkip(-1);
+    });
+
+    assert.throws(() => {
+      reader.readSkip(1000);
     });
   });
 });
@@ -652,17 +670,35 @@ describe('Setting write and read offsets', () => {
     assert.strictEqual(writer.readOffset, 10);
   });
 
-  it('should throw an error when given an offset that is out of bounds', () => {
+  it('should throw an error when given a read offset that is out of bounds', () => {
     assert.throws(() => {
       writer.readOffset = -1;
     });
+
+    assert.throws(() => {
+      writer.readOffset = 1000;
+    });
   });
 
-  it('should throw an error when given an offset that is out of bounds', () => {
+  it('should throw an error when given a write offset that is out of bounds', () => {
+    assert.throws(() => {
+      writer.writeOffset = -1;
+    });
+
     assert.throws(() => {
       writer.writeOffset = 1000;
     });
   });
+
+  it('should skip around data', () => {
+    const reader = SmartBuffer.fromBuffer(writer.toBuffer());
+    reader.readOffset += 10;
+    assert.strictEqual(reader.readStringNT(), 'mynameisjosh');
+    reader.readOffset = 0;
+    assert.strictEqual(reader.readString(5), 'hello');
+    reader.readOffset -= 5;
+    assert.strictEqual(reader.readStringNT(), 'hellotheremynameisjosh');
+  });
 });
 
 describe('Setting encoding', () => {