integration of java backend

ragconnect.base/src/main/jastadd/Configuration.jadd

@@ -4,4 +4,5 @@ aspect Configuration {
   public static TypeDecl ASTNode.rootNode;
   public static boolean ASTNode.usesMqtt;
   public static boolean ASTNode.usesRest;
+  public static boolean ASTNode.usesJava;
 }

ragconnect.base/src/main/jastadd/intermediate/Generation.jadd

@@ -15,6 +15,9 @@ aspect AttributesForMustache {
   syn String MRagConnect.restHandlerAttribute() = "_restHandler";
   syn String MRagConnect.restHandlerField() = "_restHandler";
 
+  syn String MRagConnect.javaHandlerAttribute() = "_javaHandler";
+  syn String MRagConnect.javaHandlerField() = "_javaHandler";
+
   // --- MEndpointDefinition ---
   syn String MEndpointDefinition.preemptiveExpectedValue();
   syn String MEndpointDefinition.preemptiveReturn();
@@ -141,6 +144,8 @@ aspect AttributesForMustache {
                                    result.mqttHandlerAttribute(), result.mqttHandlerField(), usesMqtt));
     result.addHandler(new MHandler("RestServerHandler", "new RestServerHandler(\"RagConnectREST\")",
                                    result.restHandlerAttribute(), result.restHandlerField(), usesRest));
+    result.addHandler(new MHandler("JavaHandler", "JavaHandler.getInstance()",
+        result.javaHandlerAttribute(), result.javaHandlerField(), usesJava));
     return result;
   }
 

ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag

@@ -6,11 +6,17 @@ aspect MustacheNodesToYAML {
     root.put("closeMethod", closeMethod());
     root.put("usesMqtt", usesMqtt);
     root.put("usesRest", usesRest);
+    root.put("usesJava", usesJava);
+
     // mqtt
     root.put("mqttHandlerField", mqttHandlerField());
     root.put("mqttHandlerAttribute", mqttHandlerAttribute());
     root.put("mqttSetupWaitUntilReadyMethod", mqttSetupWaitUntilReadyMethod());
 
+    // java
+    root.put("javaHandlerField", javaHandlerField());
+    root.put("javaHandlerAttribute", javaHandlerAttribute());
+
     // rootTypeComponents
     ListElement rootTypeComponents = new ListElement();
     for (MTypeComponent comp : getRootTypeComponentList()) {

ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java

@@ -28,6 +28,7 @@ public class Compiler extends AbstractCompiler {
 
   private static final String OPTION_PROTOCOL_MQTT = "mqtt";
   private static final String OPTION_PROTOCOL_REST = "rest";
+  private static final String OPTION_PROTOCOL_JAVA = "java";
 
   public Compiler() {
     super("ragconnect", true);
@@ -81,6 +82,9 @@ public class Compiler extends AbstractCompiler {
     if (ASTNode.usesMqtt) {
       handlers.add("MqttHandler.jadd");
     }
+    if (ASTNode.usesJava) {
+      handlers.add("JavaHandler.jadd");
+    }
     if (ASTNode.usesRest) {
       handlers.add("RestHandler.jadd");
     }
@@ -158,8 +162,9 @@ public class Compiler extends AbstractCompiler {
     optionProtocols = addOption(
         new ValueOption("protocols", "Protocols to enable")
         .acceptMultipleValues(true)
-        .addDefaultValue(OPTION_PROTOCOL_MQTT, "Enable MQTT")
+        .addDefaultValue(OPTION_PROTOCOL_JAVA, "Enable Java")
         .addAcceptedValue(OPTION_PROTOCOL_REST, "Enable REST")
+        .addAcceptedValue(OPTION_PROTOCOL_MQTT, "Enable MQTT")
     );
     optionPrintYaml = addOption(
         new BooleanOption("printYaml", "Print out YAML instead of generating files")

ragconnect.base/src/main/resources/JavaHandler.jadd

@@ -10,28 +10,28 @@ aspect JavaHandler {
     /**
      * Singleton class providing routing functionality for byte[] based message calls.
      */
-    public class CallBackRouter {
+    public class JavaHandler {
 
-        public static org.jastadd.ragconnect.jrouter.CallBackRouter ROUTER_INSTANCE = null;
+        public static JavaHandler JAVA_HANDLER_INSTANCE = null;
 
-        private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(org.jastadd.ragconnect.jrouter.CallBackRouter.class);
+        private final org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger(avaHandler.class);
 
         private Map<String, List<Consumer<byte[]>>> callbackList = new ConcurrentHashMap<>();
 
-        private CallBackRouter() {
+        private JavaHandler() {
 
         }
 
-        public synchronized static org.jastadd.ragconnect.jrouter.CallBackRouter getInstance() {
-            if(ROUTER_INSTANCE == null) {
-                ROUTER_INSTANCE = new org.jastadd.ragconnect.jrouter.CallBackRouter();
+        public synchronized static JavaHandler getInstance() {
+            if(JAVA_HANDLER_INSTANCE == null) {
+                JAVA_HANDLER_INSTANCE = new JavaHandler();
             }
-            return ROUTER_INSTANCE;
+            return JAVA_HANDLER_INSTANCE;
         }
 
-        public void registerCallback(Consumer<byte[]> callback, String topic) {
+        public void registerCallback(String topic, Consumer<byte[]> callback) {
 
-            logger.debug("[ROUTER] Registering new callback.");
+            logger.debug("[JAVA_HANDLER] Registering new callback.");
 
             List<Consumer<byte[]>> registeredCallbacks = getAllCallbacks().get(topic);
 
@@ -46,17 +46,17 @@ aspect JavaHandler {
 
         public boolean push(String topic, byte[] data) {
 
-            logger.debug("[ROUTER] Pushing a message.");
+            logger.debug("[JAVA_HANDLER] Pushing a message.");
 
             List<Consumer<byte[]>> callbacks = getAllCallbacks().get(topic);
 
             if(callbacks == null){
-                logger.error("[ROUTER] Could not publish message. No callback registered for topic " + topic);
+                logger.error("[JAVA_HANDLER] Could not publish message. No callback registered for topic " + topic);
                 return false;
             }
 
             for(Consumer<byte[]> callback : callbacks){
-                logger.debug("[ROUTER] Calling callback: " + callback.toString());
+                logger.debug("[JAVA_HANDLER] Calling callback: " + callback.toString());
                 callback.accept(data);
             }
 

ragconnect.base/src/main/resources/receiveDefinition.mustache

@@ -11,6 +11,9 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
   {{#usesMqtt}}
     case "mqtt": return {{mqttHandlerAttribute}}().newConnection(uri, consumer);
   {{/usesMqtt}}
+  {{#usesJava}}
+    case "mqtt": return {{javaHandlerAttribute}}().registerCallback(uri, consumer);
+  {{/usesJava}}
   {{#usesRest}}
     case "rest": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> {
       consumer.accept(input.getBytes());

ragconnect.base/src/main/resources/sendDefinition.mustache

@@ -20,6 +20,22 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
       }
       break;
   {{/usesMqtt}}
+  {{#usesJava}}
+      case "mqtt":
+      final MqttHandler handler = {{javaHandlerAttribute}}().resolveHandler(uri);
+      final String topic = {{javaHandlerAttribute}}().extractTopic(uri);
+      {{sender}} = () -> {
+        {{#loggingEnabledForWrites}}
+        System.out.println("[Send] {{tokenName}} = " + get{{tokenName}}() + " -> " + {{connectParameterName}});
+        {{/loggingEnabledForWrites}}
+        handler.publish(topic, {{lastValue}});
+      };
+    {{updateMethod}}();
+    if (writeCurrentValue) {
+      {{writeMethod}}();
+    }
+    break;
+  {{/usesJava}}
   {{#usesRest}}
     case "rest":
       {{restHandlerAttribute}}().newGETConnection(uri, () -> {