feat: Controller and progress

Author: righ

typescript/src/controller.ts

@@ -1,4 +1,4 @@
-
+import greedy from "./criteria/greedy";
 import hash from "./sorters/hash";
 import {
   range,
@@ -58,13 +58,15 @@ export class Controller<T extends FactorsType> {
   private parents: ParentsType = new Map();
   private indices: IndicesType = new Map();
   public incomplete: PairByKeyType = new Map();
+  private numAllChunks: number = 0;
 
   private rejected: Set<ScalarType> = new Set();
   public row: Row;
 
-  constructor(public factors: FactorsType, public options: OptionsType<T>) {
+  constructor(public factors: FactorsType, public options: OptionsType<T> = {}) {
     this.serialize(factors);
     this.setIncomplete();
+    this.numAllChunks = this.incomplete.size;
     this.row = new Row([]);
     this.factorLength = len(factors);
     this.factorIsArray = factors instanceof Array;
@@ -112,7 +114,7 @@ export class Controller<T extends FactorsType> {
     }
   }
 
-  setPair(pair: PairType) {
+  private setPair(pair: PairType) {
     for (let [key, value] of this.getCandidate(pair)) {
       this.row.set(key, value);
     }
@@ -122,20 +124,20 @@ export class Controller<T extends FactorsType> {
     }
   }
 
-  consume(pair: PairType) {
+  public consume(pair: PairType) {
     const pairKey = unique(pair);
     const deleted = this.incomplete.delete(pairKey);
     if (deleted) {
       this.row.consumed.set(pairKey, pair);
     }
   }
 
-  getCandidate(pair: PairType) {
+  public getCandidate(pair: PairType) {
     return getCandidate(pair, this.parents);
   }
 
   // Returns a negative value if it is unknown if it can be stored.
-  storable(candidate: CandidateType) {
+  public storable(candidate: CandidateType) {
     let num = 0;
     for (let [key, el] of candidate) {
       let existing: number | undefined = this.row.get(key);
@@ -165,11 +167,11 @@ export class Controller<T extends FactorsType> {
     return num;
   }
 
-  isFilled(row: Row): boolean {
+  public isFilled(row: Row): boolean {
     return row.size === this.factorLength;
   }
 
-  toMap(row: Row): Map<ScalarType, number[]> {
+  private toMap(row: Row): Map<ScalarType, number[]> {
     const result: Map<ScalarType, number[]> = new Map();
     for (let [key, serial] of row.entries()) {
       const index = this.indices.get(serial) as number;
@@ -180,35 +182,35 @@ export class Controller<T extends FactorsType> {
     return result;
   }
 
-  toProxy(row: Row) {
+  private toProxy(row: Row) {
     const obj: DictType = {};
     for (let [key, value] of this.toMap(row).entries()) {
       obj[key] = value;
     }
     return new Proxy(obj, proxyHandler) as SuggestRowType<T>;
   }
 
-  toObject(row: Row) {
+  private toObject(row: Row) {
     const obj: DictType = {};
     for (let [key, value] of this.toMap(row).entries()) {
       obj[key] = value;
     }
     return obj as SuggestRowType<T>;
   }
 
-  reset() {
+  private reset() {
     this.row.consumed.forEach((pair, pairKey) => {
       this.incomplete.set(pairKey, pair);
     });
     this.row = new Row([]);
   }
 
-  discard() {
+  private discard() {
     this.rejected.add(this.row.getPairKey());
     this.row = new Row([]);
   }
 
-  restore() {
+  private restore() {
     const row = this.row;
     this.row = new Row([]);
     if (this.factorIsArray) {
@@ -220,7 +222,7 @@ export class Controller<T extends FactorsType> {
     return this.toObject(row);
   }
 
-  close() {
+  private close() {
     const trier = new Row([...this.row.entries()]);
     const kvs = getItems(this.serials);
     for (let [k, vs] of kvs) {
@@ -274,4 +276,35 @@ export class Controller<T extends FactorsType> {
       throw e;
     }
   }
+
+  get progress() {
+    return 1 - this.incomplete.size / this.numAllChunks;
+  }
+
+  public *makeAsync<T extends FactorsType>(): Generator<SuggestRowType<T>, void, unknown> {
+    const {criterion = greedy, postFilter} = this.options;
+    do {
+      for (let pair of criterion(this)) {
+        if (this.isFilled(this.row)) {
+          break;
+        }
+        this.setPair(pair);
+      }
+      try {
+        const complete = this.close();
+        if (complete) {
+          if (!postFilter || postFilter(this.toObject(this.row))) {
+            yield this.restore() as SuggestRowType<T>;
+          } else {
+            this.discard();
+          }
+        }
+      } catch (e) {
+        if (e instanceof NeverMatch) {
+          break;
+        }
+        throw e;
+      }
+    } while (this.incomplete.size);
+  }
 }

typescript/src/index.ts

@@ -8,41 +8,13 @@ import simple from "./criteria/simple";
 import {PictConstraintsLexer} from "./utils/pict";
 import { FactorsType, OptionsType, SuggestRowType, DictType, ListType } from "./types";
 import { Controller } from "./controller";
-import { NeverMatch } from "./exceptions";
 
 const makeAsync = function* <T extends FactorsType>(
   factors: T,
   options: OptionsType<T> = {}
-) {
-  const {
-    criterion = greedy,
-    postFilter,
-  } = options;
-
+): Generator<SuggestRowType<T>, void, unknown> {
   const ctrl = new Controller(factors, options);
-  do {
-    for (let pair of criterion(ctrl)) {
-      if (ctrl.isFilled(ctrl.row)) {
-        break;
-      }
-      ctrl.setPair(pair);
-    }
-    try {
-      const complete = ctrl.close();
-      if (complete) {
-        if (!postFilter || postFilter(ctrl.toObject(ctrl.row))) {
-          yield ctrl.restore() as SuggestRowType<T>;
-        } else {
-          ctrl.discard();
-        }
-      }
-    } catch (e) {
-      if (e instanceof NeverMatch) {
-        break;
-      }
-      throw e;
-    }
-  } while (ctrl.incomplete.size);
+  yield* ctrl.makeAsync();
 };
 
 const make = <T extends FactorsType>(factors: T, options: OptionsType<T> = {}) => {
@@ -53,15 +25,16 @@ const sorters = { hash, random };
 const criteria = { greedy, simple };
 
 export { 
-  make, 
-  makeAsync, 
-  sorters, 
+  make,
+  makeAsync,
+  sorters,
   criteria,
   PictConstraintsLexer,
+  Controller,
 };
 
 export type {
-  OptionsType, 
+  OptionsType,
   SuggestRowType,
   DictType,
   ListType,