From 4ad2dd69a661c887d16986c77fdd1ab1aa53ca13 Mon Sep 17 00:00:00 2001
From: Tony Garnock-Jones <tonyg@leastfixedpoint.com>
Date: Fri, 3 Dec 2021 15:38:02 +0100
Subject: [PATCH] Update timer driver. This has exposed problems with pattern
 quoting and schema support.

---
 packages/timer/src/index.ts | 65 ++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 40 deletions(-)

diff --git a/packages/timer/src/index.ts b/packages/timer/src/index.ts
index 2db5c11..a10fb1a 100644
--- a/packages/timer/src/index.ts
+++ b/packages/timer/src/index.ts
@@ -1,69 +1,54 @@
 /// SPDX-License-Identifier: GPL-3.0-or-later
 /// SPDX-FileCopyrightText: Copyright © 2016-2021 Tony Garnock-Jones <tonyg@leastfixedpoint.com>
 
-import { preserves, Observe, Dataspace, floatValue, Facet } from "@syndicate-lang/core";
+import { preserves, Observe, floatValue, Turn, Ref } from "@syndicate-lang/core";
 
 export message type PeriodicTick(intervalMS);
 export assertion type TimeLaterThan(deadlineMS);
 
-export function sleep<T>(thisFacet: Facet<T>, ms: number, cb: () => void): void {
-  react {
-    stop on asserted TimeLaterThan(+(new Date()) + ms) {
-      cb();
+export function sleep(ds: Ref, ms: number, cb: () => void): void {
+    react {
+        at ds {
+            stop on asserted TimeLaterThan(+(new Date()) + ms) {
+                cb();
+            }
+        }
     }
-  }
 }
 
-boot {
+export function boot(ds: Ref) {
     spawn named 'timer/PeriodicTick' {
-        during Observe(PeriodicTick($intervalMS)) =>
-            spawn named (preserves`PeriodicTick(${intervalMS})`) {
-                let handle: any | null = null;
-                let finish: (() => void) | null = thisFacet.actor.dataspace.backgroundTask();
-                on start {
-                    handle = setInterval(thisFacet.wrapExternal((thisFacet) => {
+        at ds {
+            during Observe(PeriodicTick($intervalMS)) =>
+                spawn linked named (preserves`PeriodicTick(${intervalMS})`) {
+                    const thisFacet = Turn.activeFacet;
+                    thisFacet.preventInertCheck();
+                    const handle = setInterval(() => thisFacet.turn(() => {
                         send message PeriodicTick(intervalMS);
                     }), floatValue(intervalMS as any));
+                    on stop clearInterval(handle);
                 }
-                on stop {
-                    if (handle) {
-                        clearInterval(handle);
-                        handle = null;
-                    }
-                    if (finish) {
-                        finish();
-                        finish = null;
-                    }
-                }
-            }
+        }
     }
 
     spawn named 'timer/TimeLaterThan' {
-        during Observe(TimeLaterThan($deadlineMS)) =>
-            spawn named (preserves`TimeLaterThan(${deadlineMS})`) {
-                let handle: any | null = null;
-                let finish: (() => void) | null = thisFacet.actor.dataspace.backgroundTask();
-                on start {
+        at ds {
+            during Observe(TimeLaterThan($deadlineMS)) =>
+                spawn linked named (preserves`TimeLaterThan(${deadlineMS})`) {
+                    const thisFacet = Turn.activeFacet;
+                    thisFacet.preventInertCheck();
                     let delta = floatValue(deadlineMS as any) - (+(new Date()));
-                    handle = setTimeout(thisFacet.wrapExternal((thisFacet) => {
+                    let handle: any | null = setTimeout(() => thisFacet.turn(() => {
                         handle = null;
-                        if (finish) finish();
-                        finish = null;
                         react {
                             assert TimeLaterThan(deadlineMS);
                         }
                     }), delta);
-                }
-                on stop {
-                    if (handle) {
+                    on stop if (handle) {
                         clearTimeout(handle);
                         handle = null;
                     }
-                    if (finish) {
-                        finish();
-                        finish = null;
-                    }
                 }
-            }
+        }
     }
 }