feat: add compare and equals methods.

- Add compare and equals methods.
- Add test cases for compare and equals methods.
- Update eslint rule.

Author: ghosind

.eslintrc.json

@@ -24,6 +24,7 @@
         "import/prefer-default-export": "off",
         "max-classes-per-file": "off",
         "no-dupe-class-members": "off",
+        "no-restricted-syntax": "off",
         "no-unused-vars": "off"
     },
     "settings": {

src/dynamicBuffer.ts

@@ -388,6 +388,83 @@ export class DynamicBuffer {
     }(this);
   }
 
+  /**
+   * Compares this buffer with target and returns a number to indicate whether comes before, after
+   * or they are the same in sort order.
+   *
+   * ```js
+   * buf1.append('ABC');
+   * buf2.append('BCD');
+   * console.log(buf1.compare(buf2));
+   * // -1
+   * ```
+   *
+   * @param target A buffer (`DynamicBuffer` or builtin `Buffer`) or `Uint8Array` with which to
+   * compare this buffer.
+   * @param targetStart The offset within `target` at which to begin comparison, default `0`.
+   * @param targetEnd the offset within `target` at which to end comparison (not inclusive),
+   * default `target.length`.
+   * @param sourceStart The offset within this buffer at which to begin comparison, default `0`.
+   * @param sourceEnd the offset within this buffer at which to end comparison (not inclusive),
+   * default `target.length`.
+   * @returns `0` if `target` is the same as this buffer; `1` if `target` should come before this
+   * buffer when sorted; `-1` if `target` should come after this buffer when sorted.
+   */
+  compare(
+    target: DynamicBuffer | Buffer | Uint8Array,
+    targetStart: number = 0,
+    targetEnd: number = target.length,
+    sourceStart: number = 0,
+    sourceEnd: number = this.length,
+  ) {
+    const otherBuf = target instanceof DynamicBuffer ? (target.buffer || ([] as number[])) : target;
+    const thisBuf = this.buffer || ([] as number[]);
+
+    let i = targetStart;
+    let j = sourceStart;
+
+    while (i < targetEnd && j < sourceEnd && i < target.length && j < this.length) {
+      if (thisBuf[j] !== otherBuf[i]) {
+        return thisBuf[j] > otherBuf[i] ? 1 : -1;
+      }
+
+      i += 1;
+      j += 1;
+    }
+
+    if (i < targetEnd || (i < target.length && target.length < targetEnd)) {
+      return -1;
+    }
+    if (j < sourceEnd || (j < this.length && this.length < sourceEnd)) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  /**
+   * Compare this buffer with another buffer (`DynamicBuffer` or `Buffer`) or an `Uint8Array`, and
+   * returns true if they are equal, and false if not.
+   *
+   * This method is equivalent to `buf.compare(otherBuffer) === 0`.
+   *
+   * ```js
+   * const buf1 = new DynamicBuffer();
+   * buf1.append('Hello world');
+   * const buf2 = Buffer.from('Hello world');
+   *
+   * console.log(buf1.equals(buf2));
+   * // true
+   * ```
+   *
+   * @param otherBuffer A buffer (`DynamicBuffer` or builtin `Buffer`) or `Uint8Array` with which
+   * to compare this buffer.
+   * @returns `true` if two buffers have exactly the same bytes, `false` otherwise.
+   */
+  equals(otherBuffer: DynamicBuffer | Buffer | Uint8Array) {
+    return this.compare(otherBuffer, 0, otherBuffer.length, 0, this.length) === 0;
+  }
+
   /**
    * Write data into internal buffer with the specified offset.
    *

test/comparison.spec.ts

@@ -0,0 +1,139 @@
+import assert from 'assert';
+import { describe, it } from 'mocha';
+
+import { DynamicBuffer } from '../src';
+
+describe('Comparison tests', () => {
+  it('Compare with other DynamicBuffers', () => {
+    const buf1 = new DynamicBuffer();
+    const buf2 = new DynamicBuffer();
+    const buf3 = new DynamicBuffer();
+
+    buf1.append('ABC');
+    buf2.append('BCD');
+    buf3.append('ABCD');
+
+    assert.equal(buf1.compare(buf1), 0, 'expected ABC == ABC');
+    assert.equal(buf1.compare(buf2), -1, 'expect ABC < BCD');
+    assert.equal(buf1.compare(buf3), -1, 'expect ABC < ABCD');
+    assert.equal(buf2.compare(buf1), 1, 'expect BCD > ABC');
+    assert.equal(buf2.compare(buf3), 1, 'expect BCD > ABCD');
+    assert.equal(buf3.compare(buf1), 1, 'expect ABCD > ABC');
+    assert.equal(buf3.compare(buf2), -1, 'expect ABCD < BCD');
+  });
+
+  it('Compare with other Buffer (1)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABC');
+
+    const buf2 = Buffer.from('BCD');
+    const buf3 = Buffer.from('ABCD');
+
+    assert.equal(buf1.compare(buf1), 0, 'expected ABC == ABC');
+    assert.equal(buf1.compare(buf2), -1, 'expect ABC < BCD');
+    assert.equal(buf1.compare(buf3), -1, 'expect ABC < ABCD');
+  });
+
+  it('Compare with other Buffer (2)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('BCD');
+
+    const buf2 = Buffer.from('ABC');
+    const buf3 = Buffer.from('ABCD');
+
+    assert.equal(buf1.compare(buf2), 1, 'expect BCD > ABC');
+    assert.equal(buf1.compare(buf3), 1, 'expect BCD > ABCD');
+  });
+
+  it('Compare with other Buffer (3)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABCD');
+
+    const buf2 = Buffer.from('ABC');
+    const buf3 = Buffer.from('BCD');
+
+    assert.equal(buf1.compare(buf2), 1, 'expect ABCD > ABC');
+    assert.equal(buf1.compare(buf3), -1, 'expect ABCD < BCD');
+  });
+
+  it('Compare with other Uint8Array (1)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABC');
+
+    const buf2 = new Uint8Array([0x42, 0x43, 0x44]);
+    const buf3 = new Uint8Array([0x41, 0x42, 0x43, 0x44]);
+
+    assert.equal(buf1.compare(buf1), 0, 'expected ABC == ABC');
+    assert.equal(buf1.compare(buf2), -1, 'expect ABC < BCD');
+    assert.equal(buf1.compare(buf3), -1, 'expect ABC < ABCD');
+  });
+
+  it('Compare with other Uint8Array (2)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('BCD');
+
+    const buf2 = new Uint8Array([0x41, 0x42, 0x43]);
+    const buf3 = new Uint8Array([0x41, 0x42, 0x43, 0x44]);
+
+    assert.equal(buf1.compare(buf2), 1, 'expect BCD > ABC');
+    assert.equal(buf1.compare(buf3), 1, 'expect BCD > ABCD');
+  });
+
+  it('Compare with other Uint8Array (3)', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABCD');
+
+    const buf2 = new Uint8Array([0x41, 0x42, 0x43]);
+    const buf3 = new Uint8Array([0x42, 0x43, 0x44]);
+
+    assert.equal(buf1.compare(buf2), 1, 'expect ABCD > ABC');
+    assert.equal(buf1.compare(buf3), -1, 'expect ABCD < BCD');
+  });
+});
+
+describe('Equality tests', () => {
+  it('Compare equals with other DynamicBuffers', () => {
+    const buf1 = new DynamicBuffer();
+    const buf2 = new DynamicBuffer();
+    const buf3 = new DynamicBuffer();
+    const buf4 = new DynamicBuffer();
+
+    buf1.append('ABC');
+    buf2.append('ABC');
+    buf3.append('BCD');
+    buf4.append('ABCD');
+
+    assert.equal(buf1.equals(buf1), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf2), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf3), false, 'expected ABC != ABC');
+    assert.equal(buf1.equals(buf4), false, 'expected ABC != ABCD');
+  });
+
+  it('Compare equals with other Buffer', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABC');
+
+    const buf2 = Buffer.from('ABC');
+    const buf3 = Buffer.from('BCD');
+    const buf4 = Buffer.from('ABCD');
+
+    assert.equal(buf1.equals(buf1), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf2), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf3), false, 'expected ABC != ABC');
+    assert.equal(buf1.equals(buf4), false, 'expected ABC != ABCD');
+  });
+
+  it('Compare equals with other Uint8Array', () => {
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABC');
+
+    const buf2 = new Uint8Array([0x41, 0x42, 0x43]);
+    const buf3 = new Uint8Array([0x42, 0x43, 0x44]);
+    const buf4 = new Uint8Array([0x41, 0x42, 0x43, 0x44]);
+
+    assert.equal(buf1.equals(buf1), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf2), true, 'expected ABC == ABC');
+    assert.equal(buf1.equals(buf3), false, 'expected ABC != ABC');
+    assert.equal(buf1.equals(buf4), false, 'expected ABC != ABCD');
+  });
+});