Feature/multi qr code reader

.vscode/launch.json

@@ -152,6 +152,26 @@
         "./src/test/core/aztec/**/*.spec.ts"
       ],
       "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Multi-reader Tests - ts-node",
+      "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+      "args": [
+        "--require",
+        "ts-node/register",
+        "--require",
+        "tsconfig-paths/register",
+        "-u",
+        "tdd",
+        "--timeout",
+        "999999",
+        "--colors",
+        "--recursive",
+        "./src/test/core/multi/**/*.spec.ts"
+      ],
+      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

CONTRIBUTING.md

@@ -62,6 +62,8 @@ https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
 - `int` has 32 bits, signed, so `int[]` transforms to `Int32Array`.
 - `char` has 2 bytes, so `char[]` transforms to `Uint16Array`.
 - `long` has 64 bit two's complement `integer`, can be signed or unsigned.
+- `float[]` can be ported to `Float32Array`.
+- `double[]` can be ported to `Float64Array`.
 
 ### JavaScript's TypedArray
 
@@ -71,8 +73,8 @@ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
 
 - Take care of `int` -> `number` (integer to number) port when doing bitwise transformation especially `<<`. Do a `& 0xFFFFFFFF` for ints, a &0xFF for bytes.
 - Take care of array initialization, in Java `new Array(N)` initializes capacity NOT size/length.
-- Use `Math.floor` for any division of ints otherwise the `number` type is a floating point and keeps the numbers after the dot.
-- For `float` to `int` casting use `Math.trunc`, to replicate the same effect as Java casting does.
+- Use `Math.floor` for any division of `int`s otherwise the `number` type is a floating point and keeps the numbers after the dot.
+- For `float`/`number` to `int` casting use `Math.trunc`, to replicate the same effect as Java casting does.
 
 ## Encoding
 

package.json

@@ -93,7 +93,7 @@
     "nyc": "^15.1.0",
     "rollup": "^2.8.2",
     "seedrandom": "^2.4.4",
-    "sharp": "^0.22.1",
+    "sharp": "^0.26.3",
     "shx": "0.3.2",
     "sinon": "^7.2.7",
     "terser": "^5.3.7",

src/core/Reader.ts

@@ -46,8 +46,9 @@ interface Reader {
      * @throws NotFoundException if no potential barcode is found
      * @throws ChecksumException if a potential barcode is found but does not pass its checksum
      * @throws FormatException if a potential barcode is found but format is invalid
+     * @override decode
      */
-    // decode(image: BinaryBitmap): Result /*throws NotFoundException, ChecksumException, FormatException*/
+    // decodeWithoutHints(image: BinaryBitmap): Result;
 
     /**
      * Locates and decodes a barcode in some format within an image. This method also accepts

src/core/Result.ts

@@ -22,6 +22,8 @@ import ResultPoint from './ResultPoint';
 import BarcodeFormat from './BarcodeFormat';
 import System from './util/System';
 import ResultMetadataType from './ResultMetadataType';
+import { long } from 'src/customTypings';
+import { isBarcodeFormatValue } from './util/BarcodeFormaHelpers';
 
 /**
  * <p>Encapsulates the result of decoding a barcode within an image.</p>
@@ -31,44 +33,107 @@ import ResultMetadataType from './ResultMetadataType';
 export default class Result {
 
     private resultMetadata: Map<ResultMetadataType, Object>;
-
-    // public constructor(private text: string,
-    //               Uint8Array rawBytes,
-    //               ResultPoconst resultPoints: Int32Array,
-    //               BarcodeFormat format) {
-    //   this(text, rawBytes, resultPoints, format, System.currentTimeMillis())
-    // }
-
-    // public constructor(text: string,
-    //               Uint8Array rawBytes,
-    //               ResultPoconst resultPoints: Int32Array,
-    //               BarcodeFormat format,
-    //               long timestamp) {
-    //   this(text, rawBytes, rawBytes == null ? 0 : 8 * rawBytes.length,
-    //        resultPoints, format, timestamp)
-    // }
-
-    public constructor(private text: string,
+    private numBits: number;
+    private resultPoints: ResultPoint[];
+    private format: BarcodeFormat;
+
+    public constructor(
+      text: string,
+      rawBytes: Uint8Array,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+    );
+    public constructor(
+      text: string,
+      rawBytes: Uint8Array,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+      timestamp: long,
+    );
+    public constructor(
+      text: string,
+      rawBytes: Uint8Array,
+      numBits: number,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+      timestamp: number
+    );
+    public constructor(
+      private text: string,
       private rawBytes: Uint8Array,
-      private numBits: number /*int*/ = rawBytes == null ? 0 : 8 * rawBytes.length,
-      private resultPoints: ResultPoint[],
-      private format: BarcodeFormat,
-      private timestamp: number /*long*/ = System.currentTimeMillis()) {
-        this.text = text;
-        this.rawBytes = rawBytes;
-        if (undefined === numBits || null === numBits) {
-            this.numBits = (rawBytes === null || rawBytes === undefined) ? 0 : 8 * rawBytes.length;
-        } else {
-            this.numBits = numBits;
-        }
-        this.resultPoints = resultPoints;
-        this.format = format;
-        this.resultMetadata = null;
-        if (undefined === timestamp || null === timestamp) {
-            this.timestamp = System.currentTimeMillis();
-        } else {
-            this.timestamp = timestamp;
-        }
+      numBits_resultPoints: number | ResultPoint[],
+      resultPoints_format: ResultPoint[] | BarcodeFormat | any,
+      format_timestamp: BarcodeFormat | long | any = null,
+      private timestamp: long = System.currentTimeMillis()
+    ) {
+      // checks overloading order from most to least params
+
+      // check overload 3
+      if (numBits_resultPoints instanceof Number && Array.isArray(resultPoints_format) && isBarcodeFormatValue(format_timestamp)) {
+        numBits_resultPoints = rawBytes == null ? 0 : 8 * rawBytes.length;
+        this.constructor_Overload3(text, rawBytes, numBits_resultPoints, resultPoints_format, format_timestamp, timestamp);
+        return;
+      }
+
+      // check overload 2
+      if (Array.isArray(resultPoints_format) && isBarcodeFormatValue(format_timestamp)) {
+        this.constructor_Overload2(text, rawBytes, resultPoints_format, format_timestamp, timestamp);
+        return;
+      }
+
+      // check overload 1
+      if (typeof text === 'string' && rawBytes instanceof Uint8Array && Array.isArray(numBits_resultPoints) && isBarcodeFormatValue(resultPoints_format)) {
+        this.constructor_Overload1(text, rawBytes, numBits_resultPoints, resultPoints_format);
+        return;
+      }
+
+      // throw no supported overload exception
+      throw new Error('No supported overload for the given combination of parameters.');
+    }
+
+    private constructor_Overload1(
+      text: string,
+      rawBytes: Uint8Array,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+    ) {
+      return this.constructor_Overload2(text, rawBytes, resultPoints, format, System.currentTimeMillis());
+    }
+
+    private constructor_Overload2(
+      text: string,
+      rawBytes: Uint8Array,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+      timestamp: number /* long */,
+    ) {
+      return this.constructor_Overload3(text, rawBytes, rawBytes == null ? 0 : 8 * rawBytes.length,
+           resultPoints, format, timestamp);
+    }
+
+    private constructor_Overload3(
+      text: string,
+      rawBytes: Uint8Array,
+      numBits: number,
+      resultPoints: ResultPoint[],
+      format: BarcodeFormat,
+      timestamp: number
+    ) {
+      this.text = text;
+      this.rawBytes = rawBytes;
+      if (undefined === numBits || null === numBits) {
+        this.numBits = (rawBytes === null || rawBytes === undefined) ? 0 : 8 * rawBytes.length;
+      } else {
+        this.numBits = numBits;
+      }
+      this.resultPoints = resultPoints;
+      this.format = format;
+      this.resultMetadata = null;
+      if (undefined === timestamp || null === timestamp) {
+        this.timestamp = System.currentTimeMillis();
+      } else {
+        this.timestamp = timestamp;
+      }
     }
 
     /**

src/core/multi/MultipleBarcodeReader.ts

@@ -36,6 +36,7 @@ export default /*public*/ interface MultipleBarcodeReader {
 
   /**
    * @throws NotFoundException
+   * @override decodeMultiple
    */
   decodeMultiple(image: BinaryBitmap): Result[];