@dra2020/baseclient 1.0.73 → 1.0.77

package/dist/dataflow/dataflow.d.ts

@@ -1,30 +1,33 @@
+export interface IDataFlow {
+    dfid: () => any;
+}
 interface UseItem {
-    name: string;
-    df: DataFlow;
+    name?: string;
+    df: IDataFlow;
     id?: any;
+    wasstale?: boolean;
 }
 export declare class DataFlow {
-    uniquename: number;
-    usesList: {
-        [name: string]: UseItem;
-    };
+    usesList: UseItem[];
     constructor();
-    ready(): boolean;
-    id(): any;
-    value(): any;
-    uses(df: DataFlow, name?: string): void;
-    find(name: string): DataFlow;
-    findValue(name: string): any;
-    usesReady(): boolean;
+    dfid(): any;
+    compute(): void;
+    uses(df: IDataFlow, name?: string): void;
     usesStale(): boolean;
+    wasStale(name: string): boolean;
     usesRemember(): void;
+    ifcompute(): void;
 }
-export declare class DataFlowNonNull extends DataFlow {
+export declare class DataFlowCallback extends DataFlow {
     _value: any;
     _cb: () => any;
     constructor(cb: () => any);
-    ready(): boolean;
-    id(): any;
-    value(): any;
+    dfid(): any;
+}
+export declare class DataFlowStamp extends DataFlow {
+    _stamp: number;
+    constructor();
+    dfid(): any;
+    stamp(): void;
 }
 export {};

package/lib/dataflow/dataflow.ts

@@ -2,80 +2,83 @@
 // DataFlow: mechanism for setting up a data-flow dependency graph that gets computed on demand.
 //
 //  Semantics are these:
-//    1. The simplest "atomic" DataFlow object just has an id() and a value(). The id() is used to check for exact
-//       equivalence when determining if any dependents need to be recomputed. id() and value() might be the same
-//       for something that just creates a new whole object when recomputed. In other cases, id() might represent a
-//       hash or changestamp/timestamp that is distinct from the value(). The value may or may not be "ready" as well.
-//       If the value is not "ready", no dependents can be computed.
+//    1. The simplest "atomic" DataFlow object just has an id(). The id() is used to check for exact
+//       equivalence when determining if any dependents need to be recomputed.
 //    2. A DataFlow object can record that it "uses" another DataFlow object. If it does, it can use a set of helper
-//       routines to track the state of its dependents. When its dependents are all ready(), it remembers their ids
-//       and can later test if they are stale.
+//       routines to track the state of its dependents. When its dependents are "stale" (have changed) the computation
+//       needs to be run.
 //
 //
 
+export interface IDataFlow
+{
+  dfid: () => any;
+}
+
 interface UseItem
 {
-  name: string,
-  df: DataFlow,
+  name?: string;
+  df: IDataFlow,
   id?: any,
+  wasstale?: boolean,
 }
 
 export class DataFlow
 {
-  uniquename: number;
-  usesList: { [name: string]: UseItem };
+  usesList: UseItem[];
 
   constructor()
   {
-    this.usesList = {};
-    this.uniquename = 1;
+    this.usesList = [];
   }
 
   // override in subclass
-  ready(): boolean { return this.usesReady() }
-  id(): any { return null }
-  value(): any { return null }
+  dfid(): any { return null }
 
-  uses(df: DataFlow, name?: string): void
+  // override in subclass
+  compute(): void
   {
-    if (!name) name = `_df_${this.uniquename++}`;
-    this.usesList[name] = { name: name, df: df };
   }
 
-  find(name: string): DataFlow
+  uses(df: IDataFlow, name?: string): void
   {
-    let ui = this.usesList[name];
-    return ui ? ui.df : undefined;
+    this.usesList.push({ name: name, df: df });
   }
 
-  findValue(name: string): any
+  usesStale(): boolean
   {
-    let df = this.find(name);
-    return df ? df.value() : undefined;
+    let isstale = false;
+    this.usesList.forEach(ui => {
+        ui.wasstale = ui.id !== ui.df.dfid();
+        if (ui.wasstale) isstale = true;
+      });
+    return isstale;
   }
 
-  usesReady(): boolean
+  wasStale(name: string): boolean
   {
-    let isready = true;
-    Object.values(this.usesList).forEach((ui: UseItem) => { if (!ui.df.ready()) isready = false });
-    return isready;
+    let ui: UseItem = this.usesList.find((ui: UseItem) => ui.name === name);
+    return ui != null && ui.wasstale;
   }
 
-  usesStale(): boolean
+  usesRemember(): void
   {
-    let isstale = false;
-    Object.values(this.usesList).forEach((ui: UseItem) => { if (ui.df.id !== ui.df.id()) isstale = true });
-    return isstale;
+    this.usesList.forEach(ui => { ui.id = ui.df.dfid() });
   }
 
-  usesRemember(): void
+  ifcompute(): void
   {
-    Object.values(this.usesList).forEach((ui: UseItem) => { ui.df.id = ui.df.id() });
+    if (this.usesStale())
+    {
+      this.usesRemember();
+      this.compute();
+    }
   }
 }
 
-// Takes callback that, when ready, returns non-null. The return value is both the value and the id.
-export class DataFlowNonNull extends DataFlow
+// Takes callback that, eventually, returns non-null. The return value is both the value and the id.
+// Once the value returns non-null, the callback is never called again.
+export class DataFlowCallback extends DataFlow
 {
   _value: any;
   _cb: () => any;
@@ -86,21 +89,21 @@ export class DataFlowNonNull extends DataFlow
     this._cb = cb;
   }
 
-  ready(): boolean
-  {
-    // Allow chaining
-    if (!this.usesReady())
-      return false;
+  dfid(): any { if (!this._value) this._value = this._cb(); return this._value }
+}
 
-    // Real core semantics, with chaining on stale
-    if (!this._value || this.usesStale())
-    {
-      this._value = this._cb();
-      if (this._value) this.usesRemember();
-    }
-    return !!this._value;
+// Simple helper that maintains a simple monotonically increasing stamp
+export class DataFlowStamp extends DataFlow
+{
+  _stamp: number;
+
+  constructor()
+  {
+    super();
+    this._stamp = 0;
   }
 
-  id(): any { return this.ready(), this._value }
-  value(): any { return this.ready(), this._value }
+  dfid(): any { return this._stamp }
+
+  stamp(): void { this._stamp++ }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.73",
+  "version": "1.0.77",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",