first try for incremental eval usage of local ragconnect

build.gradle

@@ -56,7 +56,7 @@ dependencies {
     grammar2umlClasspath group: 'de.tudresden.inf.st', name: 'grammar2uml', version: '0.1.1'
 
 //    ragconnectClasspath group: 'de.tudresden.inf.st', name: 'ragconnect', version: '0.2.4'
-    ragconnectClasspath fileTree(include: ['ragconnect-0.2.4.jar'], dir: '/data/git/jastadd-ragconnect/ragconnect.base/build/libs')
+    ragconnectClasspath fileTree(include: ['ragconnect-0.2.5.jar'], dir: '/data/git/jastadd-ragconnect/ragconnect.base/build/libs')
 //    jastadd2 "org.jastadd:jastadd:2.3.4"
     jastadd2 fileTree(include: ['jastadd2.jar'], dir: '/data/git/jastadd-2/')
 }
@@ -87,6 +87,7 @@ task ragConnect(type: JavaExec) {
             '--o=src/gen/jastadd',
             'src/main/jastadd/MinimalModel.relast',
             'src/main/jastadd/MinimalModel.connect',
+            '--logReads',
             '--rootNode=A'
     ])
 
@@ -160,13 +161,13 @@ jastadd {
     extraJastAddOptions = [
             '--lineColumnNumbers',
             '--List=JastAddList',
-//            '--incremental=param',
-//            '--cache=all',
+            '--incremental=param',
+            '--cache=all',
 //            '--tracing=api,flush',
-//
-//            "--flush=full",
+
+            "--flush=full",
 //            "--incremental=param,debug",
-            "--tracing=api",
+            "--tracing=cache,flush",
     ]
 }
 

src/main/jastadd/MinimalModel.connect

 receive A.Input ;
 send A.OutputOnA ;
 send B.OutputOnB using Transformation ;
+send C.OutputOnC using Transformation ;
 
 // mapping definitions
 Transformation maps String s to String {:
@@ -10,3 +11,4 @@ Transformation maps String s to String {:
 // dependency definitions
 A.OutputOnA canDependOn A.Input as dependencyA ;
 B.OutputOnB canDependOn A.Input as dependencyB ;
+C.OutputOnC canDependOn A.Input as dependencyC ;

src/main/jastadd/MinimalModel.jrag

@@ -4,4 +4,8 @@ aspect Computation {
   syn String B.getOutputOnB() = "b" + input();
   inh String B.input();
   eq A.getB().input() = getInput();
+
+  syn String C.getOutputOnC() = "c" + input();
+  inh String C.input();
+  eq A.getC().input() = getInput();
 }

src/main/jastadd/MinimalModel.relast

-A ::= <Input:String> /<OutputOnA:String>/ B* ;
+A ::= <Input:String> /<OutputOnA:String>/ B* C* ;
 B ::= /<OutputOnB:String>/ ;
+C ::= /<OutputOnC:String>/ ;

src/main/java/de/tudresden/inf/st/mrc/MinimalMain.java

 package de.tudresden.inf.st.mrc;
 
 import de.tudresden.inf.st.jastadd.dumpAst.ast.Dumper;
-import de.tudresden.inf.st.mrc.ast.A;
-import de.tudresden.inf.st.mrc.ast.B;
-import de.tudresden.inf.st.mrc.ast.MqttHandler;
+import de.tudresden.inf.st.mrc.ast.*;
+import de.tudresden.inf.st.mrc.ast.ASTState.Trace.Receiver;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.io.IOException;
 import java.nio.file.Paths;
-import java.util.Scanner;
-import java.util.concurrent.TimeUnit;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
 
 /**
  * Minimal main.
@@ -23,13 +25,36 @@ public class MinimalMain {
   private static final String TOPIC_URI_FOR_INPUT = "mqtt://localhost/" + TOPIC_FOR_INPUT;
   private static MqttHandler publisher;
 
+  static class MinimalReceiver implements Receiver {
+    List<String> latestAttributes;
+    Receiver oldReceiver;
+
+    MinimalReceiver(Receiver oldReceiver) {
+      this.oldReceiver = oldReceiver;
+      reset();
+    }
+
+    void reset() {
+      latestAttributes = new ArrayList<>();
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Override
+    public void accept(ASTState.Trace.Event event, ASTNode node, String attribute, Object params, Object value) {
+      oldReceiver.accept(event, node, attribute, params, value);
+      logger.info("event: {}, node: {}, attribute: {}, params: {}, value: {},", event, node, attribute, params, value);
+      latestAttributes.add(attribute);
+    }
+  }
+  static MinimalReceiver receiver = null;
+
   public static void main(String[] args) throws Exception {
     publisher = new MqttHandler("publisher").setHost("localhost");
-    publisher.waitUntilReady(2, TimeUnit.SECONDS);
-    publisher.publish("---", "---".getBytes());
+    publisher.waitUntilReady(2, SECONDS);
+    publisher.publish("---", ("Start at " + Instant.now()).getBytes());
 
-    A normalA = addNewA();
-    enableTracing(normalA);
+    A normalA = addNewA(true);
+//    enableTracing(normalA);
     B b1 = normalA.getB(0);
     B b2 = normalA.getB(1);
 
@@ -45,55 +70,80 @@ public class MinimalMain {
     b1.connectOutputOnB("mqtt://localhost/normalA/b1/out", true);
     b2.connectOutputOnB("mqtt://localhost/normalA/b2/out", false);
 
-    A aWithNoDependency = addNewA();
-    enableTracing(aWithNoDependency);
+    A aWithNoDependency = addNewA(false);
+//    enableTracing(aWithNoDependency);
 
     aWithNoDependency.connectInput(TOPIC_URI_FOR_INPUT);
     aWithNoDependency.connectOutputOnA("mqtt://localhost/aNoDep/out", true);
-    aWithNoDependency.getB(0).connectOutputOnB("mqtt://localhost/aNoDep/b1/out", true);
-    aWithNoDependency.getB(1).connectOutputOnB("mqtt://localhost/aNoDep/b2/out", false);
+    aWithNoDependency.getC(0).connectOutputOnC("mqtt://localhost/aNoDep/c1/out", true);
+    aWithNoDependency.getC(1).connectOutputOnC("mqtt://localhost/aNoDep/c2/out", false);
 
     // stimulated incremental evaluation
-    aWithNoDependency.getB(0).getOutputOnB();
+    aWithNoDependency.getC(0).getOutputOnC();
 
-    Dumper.read(normalA).dumpAsPNG(Paths.get("images.png"));
+    Dumper.read(normalA).dumpAsPNG(Paths.get("image.png"));
 
-    waitAndRun(1, "Publish 2", () -> publisher.publish(TOPIC_FOR_INPUT, "2".getBytes()));
-    waitAndRun(2, "Disconnect normalA", () -> {
+    describedWait(1, "Publish 2");
+    publisher.publish(TOPIC_FOR_INPUT, "2".getBytes());
+
+//    aWithNoDependency.getC(0).getOutputOnC();
+
+    describedWait(2, "Disconnect normalA");
     try {
       boolean success = normalA.disconnectInput(TOPIC_URI_FOR_INPUT);
-        System.out.println("disconnect success: " + success);
+      logger.info("disconnect success: " + success);
     } catch (IOException e) {
       e.printStackTrace();
     }
-    });
-    waitAndRun(3, "Publish 4", () -> publisher.publish(TOPIC_FOR_INPUT, "4".getBytes()));
+
+//    aWithNoDependency.getC(0).getOutputOnC();
+
+    describedWait(2, "Publish 4");
+//    receiver.reset();
+    publisher.publish(TOPIC_FOR_INPUT, "4".getBytes());
+
+//    aWithNoDependency.getC(0).getOutputOnC();
+
+//    describedWait(1, "Print latest attributes");
+//    logger.info("latest attributes = {}", receiver.latestAttributes);
 
 //    while (true) {}
 //    System.out.println("[Enter] to exit");
 //    Scanner scanner = new Scanner(System.in);
 //    scanner.nextLine();
-    Thread.sleep(6);
+//    SECONDS.sleep(15);
   }
 
-  private static void waitAndRun(long seconds, String description, Runnable runnable) throws InterruptedException {
-    Thread.sleep(seconds);
-    System.out.println(description);
+  private static void describedWait(long seconds, String description) throws InterruptedException {
+    SECONDS.sleep(seconds);
+    logger.info("--- {} ---", description);
     publisher.publish("---", description.getBytes());
-    runnable.run();
   }
 
-  private static A addNewA() {
+  private static A addNewA(boolean useB) {
     A result = new A();
     result.setInput("1");
+    if (useB) {
       B b1 = new B();
       B b2 = new B();
       result.addB(b1);
       result.addB(b2);
+    } else {
+      C c1 = new C();
+      C c2 = new C();
+      result.addC(c1);
+      result.addC(c2);
+    }
     return result;
   }
 
-  private static void enableTracing(A a) {
-    a.trace().setReceiver((event, node, attribute, params, value) -> logger.info("event: {}, node: {}, attribute: {}, params: {}, value: {},", event, node, attribute, params, value));
+  private static void enableTracing(ASTNode<?> node) {
+    if (node.trace().getReceiver() != null && node.trace().getReceiver() instanceof MinimalReceiver) {
+      System.out.println("*** receiver already set up ***");
+    } else {
+      System.out.println("*** activate receiver ***");
+      receiver = new MinimalReceiver(node.trace().getReceiver());
+      node.trace().setReceiver(receiver);
+    }
   }
 }