feat: add swap methods.

Author: ghosind

src/dynamicBuffer.ts

@@ -1,7 +1,7 @@
 import { constants } from 'buffer';
 
 import { DynamicBufferIterator } from './iterator';
-import { rangeCheck } from './utils';
+import { rangeCheck, swap } from './utils';
 
 /**
  * The character encoding that is supported by Node.js, copy from Node.js Buffer module.
@@ -737,6 +737,106 @@ export class DynamicBuffer {
     return this.buffer.copy(target, targetStart, sourceStart, sourceEnd);
   }
 
+  /**
+   * Interprets buf as an array of unsigned 16-bit integers and swaps the byte order in-place.
+   *
+   * ```ts
+   * const buf = new DynamicBuffer('ABCDEFGH');
+   * buf.swap16();
+   * console.log(buf.toString());
+   * // BADCFEHG
+   * ```
+   *
+   * @returns A reference to this buffer.
+   */
+  swap16(): DynamicBuffer {
+    if (this.length % 2 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 2');
+    }
+
+    if (this.length === 0 || !this.buffer) {
+      return this;
+    }
+
+    if (this.length < 128 || typeof this.buffer.swap16 !== 'function') {
+      for (let i = 0; i < this.length; i += 2) {
+        swap(this.buffer, i, i + 1);
+      }
+    } else {
+      this.buffer.subarray(0, this.length).swap16();
+    }
+
+    return this;
+  }
+
+  /**
+   * Interprets buf as an array of unsigned 32-bit integers and swaps the byte order in-place.
+   *
+   * ```ts
+   * const buf = new DynamicBuffer('ABCDEFGH');
+   * buf.swap32();
+   * console.log(buf.toString());
+   * // DCBAHGFE
+   * ```
+   *
+   * @returns A reference to this buffer.
+   */
+  swap32(): DynamicBuffer {
+    if (this.length % 4 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 4');
+    }
+
+    if (this.length === 0 || !this.buffer) {
+      return this;
+    }
+
+    if (this.length < 192 || typeof this.buffer.swap32 !== 'function') {
+      for (let i = 0; i < this.length; i += 4) {
+        swap(this.buffer, i, i + 3);
+        swap(this.buffer, i + 1, i + 2);
+      }
+    } else {
+      this.buffer.subarray(0, this.length).swap32();
+    }
+
+    return this;
+  }
+
+  /**
+   * Interprets buf as an array of unsigned 64-bit integers and swaps the byte order in-place.
+   *
+   * ```ts
+   * const buf = new DynamicBuffer('ABCDEFGH');
+   * buf.swap64();
+   * console.log(buf.toString());
+   * // HGFEDCBA
+   * ```
+   *
+   * @returns A reference to this buffer.
+   */
+  swap64(): DynamicBuffer {
+    if (this.length % 8 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 8');
+    }
+
+    if (this.length === 0 || !this.buffer) {
+      return this;
+    }
+
+    if (this.length < 192 || typeof this.buffer.swap32 !== 'function') {
+      for (let i = 0; i < this.length; i += 8) {
+        swap(this.buffer, i, i + 7);
+        swap(this.buffer, i + 1, i + 6);
+        swap(this.buffer, i + 2, i + 5);
+        swap(this.buffer, i + 3, i + 4);
+      }
+    } else {
+      this.buffer.subarray(0, this.length).swap64();
+    }
+
+    return this;
+  }
+
   /**
    * Write data into internal buffer with the specified offset.
    *

src/utils.ts

@@ -23,3 +23,14 @@ export const rangeCheck = (field: string, value: number, min?: number, max?: num
  * ```
  */
 export const isDynamicBuffer = (val: any) => val instanceof DynamicBuffer;
+
+/**
+ * Swap two element in the buffer.
+ */
+export const swap = (buf: Buffer, i: number, j: number) => {
+  const t = buf[i];
+  // eslint-disable-next-line no-param-reassign
+  buf[i] = buf[j];
+  // eslint-disable-next-line no-param-reassign
+  buf[j] = t;
+};

test/swap.spec.ts

@@ -0,0 +1,124 @@
+import assert from 'assert';
+import { describe, it } from 'mocha';
+
+import { DynamicBuffer } from '../src';
+
+describe('Swap16 tests', () => {
+  it('Test swap16.', () => {
+    const buf = new DynamicBuffer('abcd');
+
+    buf.swap16();
+
+    assert.equal(buf.toString(), 'badc');
+  });
+
+  it('Test swap16 with empty buffer.', () => {
+    const buf = new DynamicBuffer();
+
+    buf.swap16();
+
+    assert.equal(buf.toString(), '');
+  });
+
+  it('Test swap16 with invalid length.', () => {
+    const buf = new DynamicBuffer('abc');
+
+    assert.throws(() => {
+      buf.swap16();
+    });
+  });
+
+  it('Test swap16 with long string.', () => {
+    const buf1 = new DynamicBuffer({ size: 512 });
+    const buf2 = new DynamicBuffer({ size: 512 });
+
+    for (let i = 0; i < 512; i += 2) {
+      buf1.append('AB');
+      buf2.append('BA');
+    }
+
+    buf1.swap16();
+
+    assert.equal(buf1.toString(), buf2.toString());
+  });
+});
+
+describe('Swap32 tests', () => {
+  it('Test swap32.', () => {
+    const buf = new DynamicBuffer('abcdefgh');
+
+    buf.swap32();
+
+    assert.equal(buf.toString(), 'dcbahgfe');
+  });
+
+  it('Test swap32 with empty buffer.', () => {
+    const buf = new DynamicBuffer();
+
+    buf.swap32();
+
+    assert.equal(buf.toString(), '');
+  });
+
+  it('Test swap32 with invalid length.', () => {
+    const buf = new DynamicBuffer('abc');
+
+    assert.throws(() => {
+      buf.swap32();
+    });
+  });
+
+  it('Test swap32 with long string.', () => {
+    const buf1 = new DynamicBuffer({ size: 512 });
+    const buf2 = new DynamicBuffer({ size: 512 });
+
+    for (let i = 0; i < 512; i += 4) {
+      buf1.append('ABCD');
+      buf2.append('DCBA');
+    }
+
+    buf1.swap32();
+
+    assert.equal(buf1.toString(), buf2.toString());
+  });
+});
+
+describe('Swap64 tests', () => {
+  it('Test swap64.', () => {
+    const buf = new DynamicBuffer('abcdefghijklmnop');
+
+    buf.swap64();
+
+    assert.equal(buf.toString(), 'hgfedcbaponmlkji');
+  });
+
+  it('Test swap64 with empty buffer.', () => {
+    const buf = new DynamicBuffer();
+
+    buf.swap64();
+
+    assert.equal(buf.toString(), '');
+  });
+
+  it('Test swap64 with invalid length.', () => {
+    const buf = new DynamicBuffer('abc');
+
+    assert.throws(() => {
+      buf.swap64();
+    });
+  });
+
+  it('Test swap64 with long string.', () => {
+    const buf1 = new DynamicBuffer({ size: 512 });
+    const buf2 = new DynamicBuffer({ size: 512 });
+
+    for (let i = 0; i < 512; i += 8) {
+      buf1.append('ABCDEFGH');
+      buf2.append('HGFEDCBA');
+    }
+
+    buf1.swap64();
+
+    assert.equal(buf1.toString(), buf2.toString());
+  });
+});