[Implement] Buffer.swap16/32/64 (#22)

* [Implement] Buffer.swap16/32/64

* [Cleanup] Using proper error message

Author: RedDwarfian

assembly/buffer/index.ts

@@ -237,6 +237,45 @@ export class Buffer extends Uint8Array {
     store<i64>(this.dataStart + offset, bswap<i64>(reinterpret<i64>(value)));
     return offset + 8;
   }
+
+  swap16(): Buffer {
+    let dataLength = this.dataLength;
+    // Make sure dataLength is even
+    if (dataLength & 1) throw new RangeError(E_INVALIDLENGTH);
+    let dataStart = this.dataStart;
+    dataLength += dataStart;
+    while (dataStart < dataLength) {
+      store<u16>(dataStart, bswap<u16>(load<u16>(dataStart)));
+      dataStart += 2;
+    }
+    return this;
+  }
+  
+  swap32(): Buffer {
+    let dataLength = this.dataLength;
+    // Make sure dataLength is divisible by 4
+    if (dataLength & 3) throw new RangeError(E_INVALIDLENGTH);
+    let dataStart = this.dataStart;
+    dataLength += dataStart;
+    while (dataStart < dataLength) {
+      store<u32>(dataStart, bswap<u32>(load<u32>(dataStart)));
+      dataStart += 4;
+    }
+    return this;
+  }
+  
+  swap64(): Buffer {
+    let dataLength = this.dataLength;
+    // Make sure dataLength is divisible by 8
+    if (dataLength & 7) throw new RangeError(E_INVALIDLENGTH);
+    let dataStart = this.dataStart;
+    dataLength += dataStart;
+    while (dataStart < dataLength) {
+      store<u64>(dataStart, bswap<u64>(load<u64>(dataStart)));
+      dataStart += 8;
+    }
+    return this;
+  }
 }
 
 export namespace Buffer {

assembly/node.d.ts

@@ -77,6 +77,12 @@ declare class Buffer extends Uint8Array {
   writeDoubleLE(value: f64, offset?: i32): i32;
   /** Writes an inputted 64-bit double at the designated offset, stored in Big Endian format */
   writeDoubleBE(value: f64, offset?: i32): i32;
+  /** Swaps every group of two bytes in a Buffer in-place */
+  swap16(): Buffer;
+  /** Swaps every group of four bytes in a Buffer in-place */
+  swap32(): Buffer;
+  /** Swaps every group of eight bytes in a Buffer in-place */
+  swap64(): Buffer;
 }
 
 declare namespace Buffer {

tests/buffer.spec.ts

@@ -531,6 +531,45 @@ describe("buffer", () => {
     expected = create<Buffer>([5, 6, 7]);
     expect<Buffer>(actual).toStrictEqual(expected);
   });
+
+  test("#swap16", () => {
+    let actual = create<Buffer>([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+    let expected = create<Buffer>([0x2, 0x1, 0x4, 0x3, 0x6, 0x5, 0x8, 0x7]);
+    let swapped = actual.swap16();
+    expect<Buffer>(actual).toStrictEqual(expected);
+    expect<Buffer>(swapped).toBe(actual);
+    // TODO:
+    // expectFn(() => {
+    //   let newBuff = create<Buffer>([0x1, 0x2, 0x3]);
+    //   newBuff.swap16();
+    // }).toThrow();
+  });
+
+  test("#swap32", () => {
+    let actual = create<Buffer>([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+    let expected = create<Buffer>([0x4, 0x3, 0x2, 0x1, 0x8, 0x7, 0x6, 0x5]);
+    let swapped = actual.swap32();
+    expect<Buffer>(actual).toStrictEqual(expected);
+    expect<Buffer>(swapped).toBe(actual);
+    // TODO:
+    // expectFn(() => {
+    //   let newBuff = create<Buffer>([0x1, 0x2, 0x3]);
+    //   newBuff.swap64();
+    // }).toThrow();
+  });
+
+  test("#swap64", () => {
+    let actual = create<Buffer>([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]);
+    let expected = create<Buffer>([0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8]);
+    let swapped = actual.swap64();
+    expect<Buffer>(actual).toStrictEqual(expected);
+    expect<Buffer>(swapped).toBe(actual);
+    // TODO:
+    // expectFn(() => {
+    //   let newBuff = create<Buffer>([0x1, 0x2, 0x3]);
+    //   newBuff.swap64();
+    // }).toThrow();
+  });
 
   test("#Hex.encode", () => {
     let actual = "000102030405060708090a0b0c0d0e0f102030405060708090a0b0c0d0e0f0";