Merge branch 'release-0.3.0' into 'master'

Testing incremental dependency tracking.

See merge request !5

pages/inner-workings.md → pages/docs/inner-workings.md

 # Inner workings of `RagConnect`
 
-![ros2rag-process](images/ros2rag-process.png)
+Please see [API documentation](ragdoc/index.html) for more details.
+
+![ros2rag-process](img/ros2rag-process.png)
 
 `RagConnect` uses the [relast-preprocessor](https://git-st.inf.tu-dresden.de/jastadd/relast-preprocessor) to parse `.relast` grammar files. This results in an ASTNode of type `Program`.
 It further uses a dedicated parser for `.connect` files containing endpoint-, mapping-, and dependency-definitions. This results in an ASTNode of type `RagConnect`.

pages/use_cases.md → pages/docs/use_cases.md

 # Use cases with `RagConnect`
 
-## 1⃣ MPM4CPS Paper - Codename 'Ros2Rag'
+## MPM4CPS Paper - Codename 'Ros2Rag'
 
-In the publication [*"Connecting conceptual models using Relational Reference Attribute Grammars"*](https://doi.org/10.1145/3417990.3421437), a use case involving a simulated robot arm and two different models conencted to it was shown.
+In the publication [*"Connecting conceptual models using Relational Reference Attribute Grammars"*](https://doi.org/10.1145/3417990.3421437), a use case involving a simulated robot arm and two different models connected to it was shown.
 One model was used to ensure a low speed of the robot when within a safety zone (purple boxes in the picture below), and the other model executes a workflow to control the robot.
 
-![Screenshot of Gazebo](images/robo3d.png)
+![Screenshot of Gazebo](img/robo3d.png)
 
-[📽 Recording of the simulated robot during the use case](_static/moving-robot.mp4)
+[📽 Recording of the simulated robot during the use case](img/moving-robot.mp4)
 
-This paper was presented on October, 16h during the [MPM4CPS workshop](https://msdl.uantwerpen.be/conferences/MPM4CPS/2020/) within the [MODELS 2020 conference](https://conf.researchr.org/home/models-2020). For more information, see the [presented slides](_static/mpm4cps-slides.pdf) or the [a recording of the session](https://youtu.be/Hgc1qFfmr44?t=1220).
+This paper was presented on October, 16h during the [MPM4CPS workshop](https://msdl.uantwerpen.be/conferences/MPM4CPS/2020/) within the [MODELS 2020 conference](https://conf.researchr.org/home/models-2020). For more information, see the [presented slides](img/mpm4cps-slides.pdf) or the [a recording of the session](https://youtu.be/Hgc1qFfmr44?t=1220).
 
-There is also a [poster](_static/poster.pdf) and a [pre-recorded presentation](_static/poster-presentation.mp4) of this poster.
+There is also a [poster](img/poster.pdf) and a [pre-recorded presentation](img/poster-presentation.mp4) of this poster.
 
 The repository with the used source code can be found at: <https://git-st.inf.tu-dresden.de/ceti/ros/mpm4cps2020>
 The usage is dockerized, so starting the application only involves the commands listed below.

pages/extending.md

-# Extending `RagConnect`
-
-To add a new communication protocol, the following locations have to be changed (replace `ABC` and `abc` with the name of the protocol):
-
-Within `ragconnect.base/src/main/resources`:
-- Add a new handler `ABCHandler`, if appropriate, similar to the existing handlers
-  - If further methods are needed for handler initialization, add a new template `abc.mustache` containing those procedures. Add `{{#usesABC}}{{> abc}}{{/usesABC}}` at the top of `ragconnect.mustache` to use this template
-- In `receiveDefinition.mustache` and `sendDefinition.mustache`: add a new case in the switch statement defining the logic to happen for both definitions. If the new protocol is close to a PUSH semantic, follow `mqtt`. If it is closer to PULL semantic, follow `rest`.
-
-Within `ragconnect.base/src/main/jastadd`:
-- In `backend/Configuration`:
-  - Add a new static boolean flag `usesABC` to indicate whether the protocol is used
-- In `backend/Generation`:
-  - Add new attributes for type `MRagConnect` for handler attribute and handler field, if needed
-  - Add attributes for newly introduced references in changed mustache templates, if any
-  - Add a newly constructed handler within the definition of `RagConnect.toMustache` with the needed fields (class name, construction snippet, handler attribute, handler field, the boolean flag you just added to Configuration)
-- In `backend/MustacheNodesToYAML`:
-  - Add key-value-pair for `usesABC` (and handler, if any)
-  - Add key-value-pairs for newly introduced referemces in changed mustache templates, if any
-
-In `ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java`:
-- Add a new choice for `--protocols` similar to the existing ones
-- Set the flag `usesABC` if the choice is given.
-- Add code to add the handler to the list `handlers` if the choice is given, i.e., if `ASTNode.usesABC`
-
-Furthermore, new test cases are appreciated. They can be added in the [ragconnect.rests repository](https://git-st.inf.tu-dresden.de/jastadd/ragconnect-tests)

pages/index.rst

-.. RagConnect documentation master file, created by
-   sphinx-quickstart on Fri Aug 28 10:16:26 2020.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-RagConnect Documentation
-========================
-
-`RagConnect <https://git-st.inf.tu-dresden.de/jastadd/ragconnect>`_ is a preprocessor to enable easy connection to/from models based on `Reference Attribute Grammars <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.108.8792&rep=rep1&type=pdf>`_ and `Relation Reference Attribute Grammars <https://doi.org/10.1016/j.cola.2019.100940>`_ built with `JastAdd <http://jastadd.org/>`_.
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-   use_cases.md
-   adding.md
-   inner-workings.md
-   using.md
-   extending.md
-
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`

pages/main.py

+import subprocess
+
+
+def get_version():
+    proc = subprocess.run('./gradlew printVersion --quiet',
+                          shell=True,
+                          capture_output=True,
+                          text=True,
+                          cwd='..')
+    return proc.stdout
+
+
+def define_env(env):
+    """
+    This is the hook for defining variables, macros and filters
+
+    - variables: the dictionary that contains the environment variables
+    - macro: a decorator function, to declare a macro.
+    """
+    env.conf['site_name'] = 'RagConnect ' + get_version()
+
+    @env.macro
+    def ragconnect_version():
+        return get_version()
+
+
+if __name__ == '__main__':
+    print(get_version())

pages/make.bat

-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=public
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd

pages/mkdocs.yml

+site_name: RagConnect
+nav:
+  - use_cases.md
+  - adding.md
+  - inner-workings.md
+  - using.md
+  - extending.md
+  - API documentation: ragdoc/index.html
+theme:
+  name: readthedocs
+  custom_dir: custom_theme/
+plugins:
+  - search
+  - git-revision-date-localized:
+      type: datetime
+      timezone: Europe/Berlin
+      locale: en
+      fallback_to_build_date: True
+  - macros
+repo_url: https://git-st.inf.tu-dresden.de/jastadd/ragconnect
+site_dir: ../public

ragconnect.base/build.gradle

@@ -31,7 +31,7 @@ dependencies {
     implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: "${log4j_version}"
     implementation group: 'org.apache.logging.log4j', name: 'log4j-jul', version: "${log4j_version}"
     implementation group: 'com.github.spullara.mustache.java', name: 'compiler', version: "${mustache_java_version}"
-    runtimeOnly group: 'org.jastadd', name: 'jastadd', version: '2.3.4'
+    runtimeOnly group: 'org.jastadd', name: 'jastadd', version: '2.3.5'
     api group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11'
 }
 

ragconnect.base/src/main/jastadd/Analysis.jrag

@@ -12,6 +12,19 @@ aspect Analysis {
     return result;
   }
 
+  // --- lookupTypeEndpointDefinition ---
+  inh java.util.List<TypeEndpointDefinition> TypeEndpointDefinition.lookupTypeEndpointDefinitions(TypeComponent type);
+  eq RagConnect.getEndpointDefinition().lookupTypeEndpointDefinitions(TypeComponent type) = lookupTypeEndpointDefinitions(type);
+  syn java.util.List<TypeEndpointDefinition> RagConnect.lookupTypeEndpointDefinitions(TypeComponent type) {
+    java.util.List<TypeEndpointDefinition> result = new java.util.ArrayList<>();
+    for (EndpointDefinition def : getEndpointDefinitionList()) {
+      if (def.isTypeEndpointDefinition() && def.asTypeEndpointDefinition().getType().equals(type)) {
+        result.add(def.asTypeEndpointDefinition());
+      }
+    }
+    return result;
+  }
+
   // --- lookupDependencyDefinition ---
   inh DependencyDefinition DependencyDefinition.lookupDependencyDefinition(TypeDecl source, String id);
   eq RagConnect.getDependencyDefinition().lookupDependencyDefinition(TypeDecl source, String id) {
@@ -31,10 +44,12 @@ aspect Analysis {
   }
   syn boolean DependencyDefinition.isAlreadyDefined() = lookupDependencyDefinition(getSource().containingTypeDecl(), getID()) != this;
 
+  // --- matchesType ---
   syn boolean TokenEndpointDefinition.matchesType(TokenEndpointDefinition other);
   eq ReceiveTokenEndpointDefinition.matchesType(TokenEndpointDefinition other) = other.isReceiveTokenEndpointDefinition();
   eq SendTokenEndpointDefinition.matchesType(TokenEndpointDefinition other) = other.isSendTokenEndpointDefinition();
 
+  // --- assignableTo ---
   syn boolean MappingDefinitionType.assignableTo(JavaTypeUse target);
   eq JavaMappingDefinitionType.assignableTo(JavaTypeUse target) = getType().assignableTo(target);
   eq JavaArrayMappingDefinitionType.assignableTo(JavaTypeUse target) {
@@ -47,6 +62,8 @@ aspect Analysis {
   }
   syn String JavaTypeUse.primitivePrettyPrint() {
     switch(getName()) {
+      case "boolean":
+      case "Boolean": return "boolean";
       case "int":
       case "Integer": return "int";
       case "short":
@@ -65,7 +82,17 @@ aspect Analysis {
 
   // --- shouldSendValue ---
   syn boolean TokenEndpointDefinition.shouldSendValue() = isSendTokenEndpointDefinition() && !getToken().getNTA();
+  syn boolean TypeEndpointDefinition.shouldSendValue() = isSendTypeEndpointDefinition() && !getType().getNTA();
 
   // --- needProxyToken ---
   syn boolean TokenComponent.needProxyToken() = !getDependencySourceDefinitionList().isEmpty() || getTokenEndpointDefinitionList().stream().anyMatch(TokenEndpointDefinition::shouldSendValue);
+
+  // --- effectiveUsedAt ---
+  coll Set<EndpointDefinition> MappingDefinition.effectiveUsedAt()
+    [new java.util.HashSet<EndpointDefinition>()]
+    root RagConnect;
+  EndpointDefinition contributes this
+    to MappingDefinition.effectiveUsedAt()
+    for each effectiveMappings();
+
 }

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.incrementalOptionActive;
 }

ragconnect.base/src/main/jastadd/Errors.jrag

@@ -39,10 +39,6 @@ aspect Errors {
     DependencyDefinition contributes error("The name of a dependency definition must not be equal to a list-node on the source")
       when isAlreadyDefinedAsList()
       to RagConnect.errors();
-
-    DependencyDefinition contributes error("There must be a send endpoint definition targeting " + getSource().parentTypeypeAndName() + " for dependency definition " + getID())
-      when targetEndpointDefinition() == null
-      to RagConnect.errors();
 }
 
 aspect ErrorHelpers {
@@ -54,7 +50,7 @@ aspect ErrorHelpers {
     }
     return false;
   }
-  syn String TokenComponent.parentTypeypeAndName() = containingTypeDecl().getName() + "." + getName();
+  syn String TokenComponent.parentTypeDeclAndName() = containingTypeDecl().getName() + "." + getName();
 }
 
 aspect ErrorMessage {

ragconnect.base/src/main/jastadd/NameResolution.jrag

@@ -11,4 +11,36 @@ aspect NameResolution {
     return null;
   }
 
+  refine RefResolverStubs eq ASTNode.globallyResolveTypeComponentByToken(String id) {
+    // return a TypeComponent. id is of the form 'parent_type_name + "." + child_type_name'
+    int dotIndex = id.indexOf(".");
+    String parentTypeName = id.substring(0, dotIndex);
+    String childTypeName = id.substring(dotIndex + 1);
+    TypeDecl type = program().resolveTypeDecl(parentTypeName);
+    // iterate over components and find the matching typeComponent
+    for (Component comp : type.getComponentList()) {
+      if (comp.isTypeComponent() && comp.getName().equals(childTypeName)) {
+        return comp.asTypeComponent();
+      }
+    }
+    System.err.println("Could not resolve TypeComponent '" + id + "'.");
+    return null;
+  }
+
+  refine RefResolverStubs eq ASTNode.globallyResolveComponentByToken(String id) {
+    // return a Component. id is of the form 'parent_type_name + "." + child_type_name'
+    int dotIndex = id.indexOf(".");
+    String parentTypeName = id.substring(0, dotIndex);
+    String childTypeName = id.substring(dotIndex + 1);
+    TypeDecl type = program().resolveTypeDecl(parentTypeName);
+    // iterate over components and find the matching typeComponent
+    for (Component comp : type.getComponentList()) {
+      if (comp.getName().equals(childTypeName)) {
+        return comp;
+      }
+    }
+    System.err.println("Could not resolve Component '" + id + "'.");
+    return null;
+  }
+
 }

ragconnect.base/src/main/jastadd/Navigation.jrag

@@ -27,13 +27,13 @@ aspect Navigation {
   syn TokenEndpointDefinition EndpointDefinition.asTokenEndpointDefinition() = null;
   eq TokenEndpointDefinition.asTokenEndpointDefinition() = this;
 
-  // --- isSendTokenEndpointDefinition ---
-  syn boolean EndpointDefinition.isSendTokenEndpointDefinition() = false;
-  eq SendTokenEndpointDefinition.isSendTokenEndpointDefinition() = true;
+  // --- isTypeEndpointDefinition ---
+  syn boolean EndpointDefinition.isTypeEndpointDefinition() = false;
+  eq TypeEndpointDefinition.isTypeEndpointDefinition() = true;
 
-  // --- asSendTokenEndpointDefinition ---
-  syn SendTokenEndpointDefinition EndpointDefinition.asSendTokenEndpointDefinition() = null;
-  eq SendTokenEndpointDefinition.asSendTokenEndpointDefinition() = this;
+  // --- asTypeEndpointDefinition ---
+  syn TypeEndpointDefinition EndpointDefinition.asTypeEndpointDefinition() = null;
+  eq TypeEndpointDefinition.asTypeEndpointDefinition() = this;
 
   // --- isReceiveTokenEndpointDefinition ---
   syn boolean EndpointDefinition.isReceiveTokenEndpointDefinition() = false;
@@ -43,13 +43,41 @@ aspect Navigation {
   syn ReceiveTokenEndpointDefinition EndpointDefinition.asReceiveTokenEndpointDefinition() = null;
   eq ReceiveTokenEndpointDefinition.asReceiveTokenEndpointDefinition() = this;
 
+  // --- isSendTokenEndpointDefinition ---
+  syn boolean EndpointDefinition.isSendTokenEndpointDefinition() = false;
+  eq SendTokenEndpointDefinition.isSendTokenEndpointDefinition() = true;
+
+  // --- asSendTokenEndpointDefinition ---
+  syn SendTokenEndpointDefinition EndpointDefinition.asSendTokenEndpointDefinition() = null;
+  eq SendTokenEndpointDefinition.asSendTokenEndpointDefinition() = this;
+
+  // --- isReceiveTypeEndpointDefinition ---
+  syn boolean EndpointDefinition.isReceiveTypeEndpointDefinition() = false;
+  eq ReceiveTypeEndpointDefinition.isReceiveTypeEndpointDefinition() = true;
+
+  // --- asReceiveTypeEndpointDefinition ---
+  syn ReceiveTypeEndpointDefinition EndpointDefinition.asReceiveTypeEndpointDefinition() = null;
+  eq ReceiveTypeEndpointDefinition.asReceiveTypeEndpointDefinition() = this;
+
+  // --- isSendTypeEndpointDefinition ---
+  syn boolean EndpointDefinition.isSendTypeEndpointDefinition() = false;
+  eq SendTypeEndpointDefinition.isSendTypeEndpointDefinition() = true;
+
+  // --- asSendTypeEndpointDefinition ---
+  syn SendTypeEndpointDefinition EndpointDefinition.asSendTypeEndpointDefinition() = null;
+  eq SendTypeEndpointDefinition.asSendTypeEndpointDefinition() = this;
+
   // --- targetEndpointDefinition ---
-  syn SendTokenEndpointDefinition DependencyDefinition.targetEndpointDefinition() {
+  syn EndpointDefinition DependencyDefinition.targetEndpointDefinition() {
     // resolve definition in here, as we do not need resolveMethod in any other place (yet)
     for (EndpointDefinition endpointDefinition : ragconnect().getEndpointDefinitionList()) {
       if (endpointDefinition.isSendTokenEndpointDefinition() &&
           endpointDefinition.asSendTokenEndpointDefinition().getToken().equals(this.getTarget())) {
-        return endpointDefinition.asSendTokenEndpointDefinition();
+        return endpointDefinition;
+      }
+      if (endpointDefinition.isSendTypeEndpointDefinition() &&
+          endpointDefinition.asSendTypeEndpointDefinition().getType().equals(this.getTarget())) {
+        return endpointDefinition;
       }
     }
     return null;

ragconnect.base/src/main/jastadd/RagConnect.relast

@@ -10,9 +10,15 @@ rel TokenEndpointDefinition.Token <-> TokenComponent.TokenEndpointDefinition*;
 ReceiveTokenEndpointDefinition : TokenEndpointDefinition;
 SendTokenEndpointDefinition : TokenEndpointDefinition;
 
+abstract TypeEndpointDefinition : EndpointDefinition;
+rel TypeEndpointDefinition.Type <-> TypeComponent.TypeEndpointDefinition*;
+
+ReceiveTypeEndpointDefinition : TypeEndpointDefinition;
+SendTypeEndpointDefinition : TypeEndpointDefinition;
+
 DependencyDefinition ::= <ID>;
 rel DependencyDefinition.Source <-> TokenComponent.DependencySourceDefinition*;
-rel DependencyDefinition.Target -> TokenComponent;
+rel DependencyDefinition.Target -> Component;
 
 MappingDefinition ::= <ID> FromType:MappingDefinitionType <FromVariableName> ToType:MappingDefinitionType <Content> ;
 abstract MappingDefinitionType ::= ;

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

@@ -18,29 +18,46 @@ aspect AttributesForMustache {
   // --- MEndpointDefinition ---
   syn String MEndpointDefinition.preemptiveExpectedValue();
   syn String MEndpointDefinition.preemptiveReturn();
-  syn TokenEndpointDefinition MEndpointDefinition.endpointDef();
+  syn EndpointDefinition MEndpointDefinition.endpointDef();
   syn String MEndpointDefinition.firstInputVarName();
+  syn String MEndpointDefinition.parentTypeName();
+  syn String MEndpointDefinition.entityName();
+  syn String MEndpointDefinition.updateMethod();
+  syn String MEndpointDefinition.writeMethod();
 
   eq MEndpointDefinition.getInnerMappingDefinition(int i).isLast() = i == getNumInnerMappingDefinition() - 1;
   eq MEndpointDefinition.getInnerMappingDefinition(int i).inputVarName() = i == 0 ? firstInputVarName() : getInnerMappingDefinition(i - 1).outputVarName();
 
   syn String MEndpointDefinition.connectParameterName() = "uriString";
-  syn String MEndpointDefinition.connectMethod() = "connect" + tokenName();
+  syn String MEndpointDefinition.connectMethod() = "connect" + entityName();
+  syn boolean MEndpointDefinition.isTypeEndpointDefinition() = endpointDef().isTypeEndpointDefinition();
 
   syn String MEndpointDefinition.disconnectMethod() {
     // if both (send and receive) are defined for the token, ensure methods with different names
-    String extra = endpointDef().lookupTokenEndpointDefinitions(token()).size() > 1 ? uniqueSuffix() : "";
-    return "disconnect" + extra + tokenName();
+    String extra;
+    if (endpointDef().isTokenEndpointDefinition()) {
+      extra = endpointDef().asTokenEndpointDefinition().lookupTokenEndpointDefinitions(token()).size() > 1 ? uniqueSuffix() : "";
+    } else if (endpointDef().isTypeEndpointDefinition()) {
+      extra = endpointDef().asTypeEndpointDefinition().lookupTypeEndpointDefinitions(type()).size() > 1 ? uniqueSuffix() : "";
+    } else {
+      extra = "";
+    }
+    return "disconnect" + extra + entityName();
   }
-  //
+
   syn String MEndpointDefinition.uniqueSuffix();
-  eq MSendDefinition.uniqueSuffix() = "Send";
-  eq MReceiveDefinition.uniqueSuffix() = "Receive";
+  eq MTokenSendDefinition.uniqueSuffix() = "Send";
+  eq MTokenReceiveDefinition.uniqueSuffix() = "Receive";
+  eq MTypeSendDefinition.uniqueSuffix() = "Send";
+  eq MTypeReceiveDefinition.uniqueSuffix() = "Receive";
 
-  syn TokenComponent MEndpointDefinition.token() = endpointDef().getToken();
+  // TODO potentially dangerous because asXEndpointDefinition can return null
+  syn TokenComponent MEndpointDefinition.token() = endpointDef().asTokenEndpointDefinition().getToken();
+  syn TypeComponent MEndpointDefinition.type() = endpointDef().asTypeEndpointDefinition().getType();
   syn boolean MEndpointDefinition.alwaysApply() = endpointDef().getAlwaysApply();
-  syn String MEndpointDefinition.parentTypeName() = token().containingTypeDecl().getName();
   syn String MEndpointDefinition.tokenName() = token().getName();
+  syn String MEndpointDefinition.typeName() = type().getName();
+  syn String MEndpointDefinition.typeDeclName() = type().getTypeDecl().getName();
   syn MInnerMappingDefinition MEndpointDefinition.lastDefinition() = getInnerMappingDefinition(getNumInnerMappingDefinition() - 1);
   syn String MEndpointDefinition.lastDefinitionToType() = lastDefinition().toType();
   syn String MEndpointDefinition.lastResult() = lastDefinition().outputVarName();
@@ -48,15 +65,23 @@ aspect AttributesForMustache {
     if (lastDefinition().mappingDef().getToType().isArray()) {
       return "java.util.Arrays.equals(" + preemptiveExpectedValue() + ", " + lastResult() + ")";
     }
-    if (token().isPrimitiveType() && lastDefinition().mappingDef().getToType().isPrimitiveType()) {
+    if (endpointDef().isTokenEndpointDefinition() && token().isPrimitiveType() && lastDefinition().mappingDef().getToType().isPrimitiveType()) {
       return preemptiveExpectedValue() + " == " + lastResult();
     }
-    if (lastDefinition().mappingDef().isDefaultMappingDefinition()) {
+    if (lastDefinition().mappingDef().getToType().isPrimitiveType() || lastDefinition().mappingDef().isDefaultMappingDefinition()) {
       return preemptiveExpectedValue() + " != null && " + preemptiveExpectedValue() + ".equals(" + lastResult() + ")";
     }
     return preemptiveExpectedValue() + " != null ? " + preemptiveExpectedValue() + ".equals(" + lastResult() + ") : " + lastResult() + " == null";
   }
 
+  // --- MTokenEndpointDefinition ---
+  eq MTokenEndpointDefinition.parentTypeName() = token().containingTypeDecl().getName();
+  eq MTokenEndpointDefinition.entityName() = tokenName();
+
+  // --- MTypeEndpointDefinition ---
+  eq MTypeEndpointDefinition.parentTypeName() = type().containingTypeDecl().getName();
+  eq MTypeEndpointDefinition.entityName() = typeName();
+
   // --- MInnerMappingDefinition ---
   inh boolean MInnerMappingDefinition.isLast();
   inh String MInnerMappingDefinition.inputVarName();
@@ -65,24 +90,47 @@ aspect AttributesForMustache {
   syn MappingDefinition MInnerMappingDefinition.mappingDef() = getMMappingDefinition().getMappingDefinition();
   syn String MInnerMappingDefinition.outputVarName() = "result" + methodName();  // we do not need "_" in between here, because methodName begins with one
 
-  // --- MReceiveDefinition ---
-  eq MReceiveDefinition.preemptiveExpectedValue() = "get" + tokenName() + "()";
-  eq MReceiveDefinition.preemptiveReturn() = "return;";
-  eq MReceiveDefinition.endpointDef() = getReceiveTokenEndpointDefinition();
-  eq MReceiveDefinition.firstInputVarName() = "message";
-
-  // --- MSendDefinition ---
-  eq MSendDefinition.preemptiveExpectedValue() = lastValue();
-  eq MSendDefinition.preemptiveReturn() = "return false;";
-  eq MSendDefinition.endpointDef() = getSendTokenEndpointDefinition();
-  eq MSendDefinition.firstInputVarName() = "get" + tokenName() + "()";
-
-  syn String MSendDefinition.sender() = "_sender_" + tokenName();
-  syn String MSendDefinition.lastValue() = "_lastValue" + tokenName();
-  syn String MSendDefinition.updateMethod() = "_update_" + tokenName();
-  syn String MSendDefinition.writeMethod() = "_writeLastValue_" + tokenName();
-  syn String MSendDefinition.tokenResetMethod() = "get" + tokenName() + "_reset";
-  syn boolean MSendDefinition.shouldSendValue() = endpointDef().shouldSendValue();
+  // --- MTokenReceiveDefinition ---
+  eq MTokenReceiveDefinition.preemptiveExpectedValue() = "get" + tokenName() + "()";
+  eq MTokenReceiveDefinition.preemptiveReturn() = "return;";
+  eq MTokenReceiveDefinition.endpointDef() = getReceiveTokenEndpointDefinition();
+  eq MTokenReceiveDefinition.firstInputVarName() = "message";
+  eq MTokenReceiveDefinition.updateMethod() = null;
+  eq MTokenReceiveDefinition.writeMethod() = null;
+
+  // --- MTokenSendDefinition ---
+  eq MTokenSendDefinition.preemptiveExpectedValue() = lastValue();
+  eq MTokenSendDefinition.preemptiveReturn() = "return false;";
+  eq MTokenSendDefinition.endpointDef() = getSendTokenEndpointDefinition();
+  eq MTokenSendDefinition.firstInputVarName() = "get" + tokenName() + "()";
+  eq MTokenSendDefinition.updateMethod() = "_update_" + tokenName();
+  eq MTokenSendDefinition.writeMethod() = "_writeLastValue_" + tokenName();
+
+  syn String MTokenSendDefinition.sender() = "_sender_" + tokenName();
+  syn String MTokenSendDefinition.lastValue() = "_lastValue" + tokenName();
+  syn String MTokenSendDefinition.tokenResetMethod() = "get" + tokenName() + "_reset";
+  syn boolean MTokenSendDefinition.shouldSendValue() = endpointDef().asTokenEndpointDefinition().shouldSendValue();
+
+  // MTypeReceiveDefinition
+  eq MTypeReceiveDefinition.preemptiveExpectedValue() = "get" + typeName() + "()";
+  eq MTypeReceiveDefinition.preemptiveReturn() = "return;";
+  eq MTypeReceiveDefinition.endpointDef() = getReceiveTypeEndpointDefinition();
+  eq MTypeReceiveDefinition.firstInputVarName() = "message";
+  eq MTypeReceiveDefinition.updateMethod() = null;
+  eq MTypeReceiveDefinition.writeMethod() = null;
+
+  // MTypeSendDefinition
+  eq MTypeSendDefinition.preemptiveExpectedValue() = lastValue();
+  eq MTypeSendDefinition.preemptiveReturn() = "return false;";
+  eq MTypeSendDefinition.endpointDef() = getSendTypeEndpointDefinition();
+  eq MTypeSendDefinition.firstInputVarName() = "get" + typeName() + "()";
+  eq MTypeSendDefinition.updateMethod() = "_update_" + typeName();
+  eq MTypeSendDefinition.writeMethod() = "_writeLastValue_" + typeName();
+
+  syn String MTypeSendDefinition.sender() = "_sender_" + typeName();
+  syn String MTypeSendDefinition.lastValue() = "_lastValue" + typeName();
+  syn String MTypeSendDefinition.tokenResetMethod() = "get" + typeName() + "_reset";
+  syn boolean MTypeSendDefinition.shouldSendValue() = endpointDef().asTypeEndpointDefinition().shouldSendValue();
 
   // --- MMappingDefinition ---
   syn String MMappingDefinition.toType() = getMappingDefinition().getToType().prettyPrint();
@@ -90,13 +138,14 @@ aspect AttributesForMustache {
   syn String MMappingDefinition.fromType() = getMappingDefinition().getFromType().prettyPrint();
   syn String MMappingDefinition.fromVariableName() = getMappingDefinition().getFromVariableName();
   syn String MMappingDefinition.content() = getMappingDefinition().getContent();
+  syn boolean MMappingDefinition.isUsed() = !getMappingDefinition().effectiveUsedAt().isEmpty();
 
   // --- MDependencyDefinition ---
   syn String MDependencyDefinition.targetParentTypeName() = getDependencyDefinition().getTarget().containingTypeDecl().getName();
   syn String MDependencyDefinition.dependencyMethod() = "add" + capitalize(getDependencyDefinition().getID());
   syn String MDependencyDefinition.sourceParentTypeName() = getDependencyDefinition().getSource().containingTypeDecl().getName();
   syn String MDependencyDefinition.internalRelationPrefix() = "_internal_" + getDependencyDefinition().getID();
-  syn nta MSendDefinition MDependencyDefinition.targetEndpointDefinition() {
+  syn nta MEndpointDefinition MDependencyDefinition.targetEndpointDefinition() {
     return getDependencyDefinition().targetEndpointDefinition().toMustache();
   }
 
@@ -110,7 +159,7 @@ aspect AttributesForMustache {
   syn String MTokenComponent.javaType() = getTokenComponent().effectiveJavaTypeUse().prettyPrint();
   syn String MTokenComponent.internalName() = getTokenComponent().needProxyToken() ? "_internal_" + name() : externalName();
   syn String MTokenComponent.externalName() = name();
-  syn MSendDefinition MTokenComponent.normalTokenSendDef() {
+  syn MTokenSendDefinition MTokenComponent.normalTokenSendDef() {
     for (TokenEndpointDefinition endpointDef : getTokenComponent().getTokenEndpointDefinitionList()) {
       if (endpointDef.shouldSendValue()) {
         return endpointDef.asSendTokenEndpointDefinition().toMustache();
@@ -124,11 +173,16 @@ aspect AttributesForMustache {
     MRagConnect result = new MRagConnect();
     result.setRagConnect(this);
     for (EndpointDefinition def : getEndpointDefinitionList()) {
-      if (def.isSendTokenEndpointDefinition()) {
-        SendTokenEndpointDefinition sendDef = def.asSendTokenEndpointDefinition();
-        result.addSendDefinition(sendDef.toMustache());
+      if (def.isReceiveTokenEndpointDefinition()) {
+        result.addTokenReceiveDefinition(def.asReceiveTokenEndpointDefinition().toMustache());
+      } else if (def.isSendTokenEndpointDefinition()) {
+        result.addTokenSendDefinition(def.asSendTokenEndpointDefinition().toMustache());
+      } else if (def.isReceiveTypeEndpointDefinition()) {
+        result.addTypeReceiveDefinition(def.asReceiveTypeEndpointDefinition().toMustache());
+      } else if (def.isSendTypeEndpointDefinition()) {
+        result.addTypeSendDefinition(def.asSendTypeEndpointDefinition().toMustache());
       } else {
-        result.addReceiveDefinition(def.asReceiveTokenEndpointDefinition().toMustache());
+        throw new RuntimeException("Unknown endpoint definition: " + def);
       }
     }
     for (MappingDefinition def : allMappingDefinitions()) {
@@ -163,20 +217,35 @@ aspect AttributesForMustache {
     }
   }
 
-  syn lazy MReceiveDefinition ReceiveTokenEndpointDefinition.toMustache() {
-    MReceiveDefinition result = new MReceiveDefinition();
+  public abstract MEndpointDefinition EndpointDefinition.toMustache();
+  syn lazy MTokenReceiveDefinition ReceiveTokenEndpointDefinition.toMustache() {
+    MTokenReceiveDefinition result = new MTokenReceiveDefinition();
     result.setReceiveTokenEndpointDefinition(this);
     result.addInnerMappings();
     return result;
   }
 
-  syn lazy MSendDefinition SendTokenEndpointDefinition.toMustache() {
-    MSendDefinition result = new MSendDefinition();
+  syn lazy MTokenSendDefinition SendTokenEndpointDefinition.toMustache() {
+    MTokenSendDefinition result = new MTokenSendDefinition();
     result.setSendTokenEndpointDefinition(this);
     result.addInnerMappings();
     return result;
   }
 
+  syn lazy MTypeReceiveDefinition ReceiveTypeEndpointDefinition.toMustache() {
+    MTypeReceiveDefinition result = new MTypeReceiveDefinition();
+    result.setReceiveTypeEndpointDefinition(this);
+    result.addInnerMappings();
+    return result;
+  }
+
+  syn lazy MTypeSendDefinition SendTypeEndpointDefinition.toMustache() {
+    MTypeSendDefinition result = new MTypeSendDefinition();
+    result.setSendTypeEndpointDefinition(this);
+    result.addInnerMappings();
+    return result;
+  }
+
   syn lazy MMappingDefinition MappingDefinition.toMustache() {
     MMappingDefinition result = new MMappingDefinition();
     result.setMappingDefinition(this);

ragconnect.base/src/main/jastadd/intermediate/Mappings.jrag

@@ -10,9 +10,9 @@ aspect DefaultMappings {
         new JavaMappingDefinitionType(new SimpleJavaTypeUse(typeName));
   }
 
-  private DefaultMappingDefinition RagConnect.baseDefaultMappingDefinition(String fromTypeName, String toTypeName, String content) {
+  private DefaultMappingDefinition RagConnect.createDefaultMappingDefinition(String prefix, String fromTypeName, String toTypeName, String content) {
     DefaultMappingDefinition result = new DefaultMappingDefinition();
-    result.setID("_Default" + baseDefaultMappingTypeNamePart(fromTypeName) + "To" + baseDefaultMappingTypeNamePart(toTypeName) + "Mapping");
+    result.setID(prefix + baseDefaultMappingTypeNamePart(fromTypeName) + "To" + baseDefaultMappingTypeNamePart(toTypeName) + "Mapping");
     result.setFromType(baseDefaultMappingTypeFromName(fromTypeName));
     result.setFromVariableName("input");
     result.setToType(baseDefaultMappingTypeFromName(toTypeName));
@@ -20,6 +20,16 @@ aspect DefaultMappings {
     return result;
   }
 
+  private DefaultMappingDefinition RagConnect.baseDefaultMappingDefinition(String fromTypeName, String toTypeName, String content) {
+    return createDefaultMappingDefinition("_Default", fromTypeName, toTypeName, content);
+  }
+
+  private DefaultMappingDefinition RagConnect.treeDefaultMappingDefinition(String fromTypeName, String toTypeName, String content) {
+    return createDefaultMappingDefinition("_TreeDefault", fromTypeName, toTypeName, content);
+  }
+
+  syn nta DefaultMappingDefinition RagConnect.defaultBytesToBooleanMapping() = baseDefaultMappingDefinition(
+      "byte[]", "boolean", "return input[0] == (byte) 1;");
   syn nta DefaultMappingDefinition RagConnect.defaultBytesToIntMapping() = baseDefaultMappingDefinition(
       "byte[]", "int", "return java.nio.ByteBuffer.wrap(input).getInt();");
   syn nta DefaultMappingDefinition RagConnect.defaultBytesToShortMapping() = baseDefaultMappingDefinition(
@@ -35,6 +45,30 @@ aspect DefaultMappings {
   syn nta DefaultMappingDefinition RagConnect.defaultBytesToStringMapping() = baseDefaultMappingDefinition(
       "byte[]", "String", "return new String(input);");
 
+  syn nta DefaultMappingDefinition RagConnect.defaultBytesToTreeMapping(String typeName) {
+    return treeDefaultMappingDefinition("byte[]", typeName,
+      "String content = new String(input);\n" +
+      "com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();\n" +
+      "com.fasterxml.jackson.core.JsonFactory factory = new com.fasterxml.jackson.core.JsonFactory();\n" +
+      "com.fasterxml.jackson.core.JsonParser parser = factory.createParser(content);\n" +
+      typeName + " result = " + typeName + ".deserialize((com.fasterxml.jackson.databind.JsonNode)mapper.readTree(parser));\n" +
+      "parser.close();\n" +
+      "return result;"
+    );
+  }
+  syn nta DefaultMappingDefinition RagConnect.defaultTreeToBytesMapping(String typeName) {
+    return treeDefaultMappingDefinition(typeName, "byte[]",
+      "java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();\n" +
+      "com.fasterxml.jackson.core.JsonFactory factory = new com.fasterxml.jackson.core.JsonFactory();\n" +
+      "com.fasterxml.jackson.core.JsonGenerator generator = factory.createGenerator(outputStream, com.fasterxml.jackson.core.JsonEncoding.UTF8);\n"+
+      "input.serialize(generator);\n" +
+      "generator.flush();\n" +
+      "return outputStream.toString().getBytes();"
+    );
+  }
+
+  syn nta DefaultMappingDefinition RagConnect.defaultBooleanToBytesMapping() = baseDefaultMappingDefinition(
+        "boolean", "byte[]", "return java.nio.ByteBuffer.allocate(1).put((byte) (input ? 1 : 0)).array();");
   syn nta DefaultMappingDefinition RagConnect.defaultIntToBytesMapping() = baseDefaultMappingDefinition(
       "int", "byte[]", "return java.nio.ByteBuffer.allocate(Integer.BYTES).putInt(input).array();");
   syn nta DefaultMappingDefinition RagConnect.defaultShortToBytesMapping() = baseDefaultMappingDefinition(
@@ -50,6 +84,8 @@ aspect DefaultMappings {
   syn nta DefaultMappingDefinition RagConnect.defaultStringToBytesMapping() = baseDefaultMappingDefinition(
       "String", "byte[]", "return input.getBytes();");
 
+  syn nta DefaultMappingDefinition RagConnect.defaultStringToBooleanMapping() = baseDefaultMappingDefinition(
+      "String", "boolean", "return Boolean.parseBoolean(input);");
   syn nta DefaultMappingDefinition RagConnect.defaultStringToIntMapping() = baseDefaultMappingDefinition(
       "String", "int", "return Integer.parseInt(input);");
   syn nta DefaultMappingDefinition RagConnect.defaultStringToShortMapping() = baseDefaultMappingDefinition(
@@ -63,6 +99,8 @@ aspect DefaultMappings {
   syn nta DefaultMappingDefinition RagConnect.defaultStringToCharMapping() = baseDefaultMappingDefinition(
       "String", "char", "return input.charAt(0);");
 
+  syn nta DefaultMappingDefinition RagConnect.defaultBooleanToStringMapping() = baseDefaultMappingDefinition(
+      "boolean", "String", "return String.valueOf(input);");
   syn nta DefaultMappingDefinition RagConnect.defaultIntToStringMapping() = baseDefaultMappingDefinition(
       "int", "String", "return String.valueOf(input);");
   syn nta DefaultMappingDefinition RagConnect.defaultShortToStringMapping() = baseDefaultMappingDefinition(
@@ -79,50 +117,39 @@ aspect DefaultMappings {
 
 aspect Mappings {
   // --- effectiveMappings ---
-  syn java.util.List<MappingDefinition> EndpointDefinition.effectiveMappings();
-  eq ReceiveTokenEndpointDefinition.effectiveMappings() {
-    // if there is a first mapping, check if it is suitable.
-    //  or if no mappings are specified.
-    // then prepend the suitable default mapping
+  syn java.util.List<MappingDefinition> EndpointDefinition.effectiveMappings() {
     java.util.List<MappingDefinition> result;
-    if (getMappingList().isEmpty() || !hasSuitableEdgeMapping()) {
+    if (isReceiveTokenEndpointDefinition() || isReceiveTypeEndpointDefinition()) {
+      // if no mappings are specified, or if first mapping is not suitable.
+      // then prepend the suitable default mapping
+      if (getMappingList().isEmpty() || !getMappingList().get(0).getFromType().isByteArray()) {
         result = new java.util.ArrayList();
-      result.add(suitableDefaultMapping());
+        result.add(suitableReceiveDefaultMapping());
         result.addAll(getMappingList());
       } else {
         result = getMappingList();
       }
-    return result;
-  }
-  eq SendTokenEndpointDefinition.effectiveMappings() {
-    // if there is a mapping, check if it is suitable.
-    //  or if no mappings are specified.
+    } else if (isSendTokenEndpointDefinition() || isSendTypeEndpointDefinition()) {
+      // if no mappings are specified, or if last mapping is not suitable
       // then append the suitable default mapping
-    java.util.List<MappingDefinition> result;
-    if (getMappingList().isEmpty() || !hasSuitableEdgeMapping()) {
+      if (getMappingList().isEmpty() || !getMappingList().get(getMappingList().size() - 1).getToType().isByteArray()) {
         result = new java.util.ArrayList(getMappingList());
-      result.add(suitableDefaultMapping());
+        result.add(suitableSendDefaultMapping());
       } else {
         result = getMappingList();
       }
+    } else {
+      throw new RuntimeException("Unknown endpoint definition: " + this);
+    }
     return result;
   }
 
-  // --- hasSuitableEdgeMapping ---
-  syn boolean TokenEndpointDefinition.hasSuitableEdgeMapping();
-  eq ReceiveTokenEndpointDefinition.hasSuitableEdgeMapping() = isSuitableEdgeMapping(getMappingList().get(0));
-  eq SendTokenEndpointDefinition.hasSuitableEdgeMapping() = isSuitableEdgeMapping(getMappingList().get(getMappingList().size() - 1));
-
-  // --- isSuitableEdgeMapping(def) ---
-  syn boolean TokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def);
-  eq ReceiveTokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def) = def.getFromType().isByteArray();
-  eq SendTokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def) = def.getToType().isByteArray();
-
   // --- isPrimitiveType ---
   syn boolean TokenComponent.isPrimitiveType() = effectiveJavaTypeUse().isPrimitiveType();
   syn boolean JavaTypeUse.isPrimitiveType() = false;
   eq SimpleJavaTypeUse.isPrimitiveType() {
     switch(getName()) {
+      case "boolean":
       case "int":
       case "short":
       case "long":
@@ -140,13 +167,11 @@ aspect Mappings {
   syn boolean MappingDefinitionType.isArray() = false;
   eq JavaArrayMappingDefinitionType.isArray() = true;
 
-  // --- suitableDefaultMapping ---
-  syn DefaultMappingDefinition EndpointDefinition.suitableDefaultMapping();
-  eq ReceiveTokenEndpointDefinition.suitableDefaultMapping() {
-    String typeName = getMappingList().isEmpty() ?
-        getToken().effectiveJavaTypeUse().getName() :
-        getMappingList().get(0).getFromType().prettyPrint();
-    switch(typeName) {
+  // --- suitableReceiveDefaultMapping ---
+  syn DefaultMappingDefinition EndpointDefinition.suitableReceiveDefaultMapping() {
+    switch (targetTypeName()) {
+      case "boolean":
+      case "Boolean": return ragconnect().defaultBytesToBooleanMapping();
       case "int":
       case "Integer": return ragconnect().defaultBytesToIntMapping();
       case "short":
@@ -160,14 +185,20 @@ aspect Mappings {
       case "char":
       case "Character": return ragconnect().defaultBytesToCharMapping();
       case "String": return ragconnect().defaultBytesToStringMapping();
-      default: return null;
+      default:
+        try {
+            TypeDecl typeDecl = program().resolveTypeDecl(targetTypeName());
+            return ragconnect().defaultBytesToTreeMapping(typeDecl.getName());
+        } catch (Exception ignore) {}
+        System.err.println("Could not find suitable default mapping for " + targetTypeName() + " on " + this);
+        return null;
     }
   }
-  eq SendTokenEndpointDefinition.suitableDefaultMapping() {
-    String typeName = getMappingList().isEmpty() ?
-        getToken().effectiveJavaTypeUse().getName() :
-        getMappingList().get(getMappingList().size() - 1).getFromType().prettyPrint();
-    switch(typeName) {
+  // --- suitableSendDefaultMapping ---
+  syn DefaultMappingDefinition EndpointDefinition.suitableSendDefaultMapping() {
+    switch (targetTypeName()) {
+      case "boolean":
+      case "Boolean": return ragconnect().defaultBooleanToBytesMapping();
       case "int":
       case "Integer": return ragconnect().defaultIntToBytesMapping();
       case "short":
@@ -181,9 +212,39 @@ aspect Mappings {
       case "char":
       case "Character": return ragconnect().defaultCharToBytesMapping();
       case "String": return ragconnect().defaultStringToBytesMapping();
-      default: return null;
+      default:
+        try {
+            TypeDecl typeDecl = program().resolveTypeDecl(targetTypeName());
+            return ragconnect().defaultTreeToBytesMapping(typeDecl.getName());
+        } catch (Exception ignore) {}
+        System.err.println("Could not find suitable default mapping for " + targetTypeName() + " on " + this);
+        return null;
+    }
+  }
+
+  // --- targetTypeName ---
+  syn String EndpointDefinition.targetTypeName();
+  eq ReceiveTokenEndpointDefinition.targetTypeName() {
+    return getMappingList().isEmpty() ?
+           getToken().effectiveJavaTypeUse().getName() :
+           getMappingList().get(0).getFromType().prettyPrint();
+  }
+  eq ReceiveTypeEndpointDefinition.targetTypeName() {
+    return getMappingList().isEmpty() ?
+           getType().getTypeDecl().getName() :
+           getMappingList().get(0).getFromType().prettyPrint();
   }
+  eq SendTokenEndpointDefinition.targetTypeName() {
+    return getMappingList().isEmpty() ?
+           getToken().effectiveJavaTypeUse().getName() :
+           getMappingList().get(getMappingList().size() - 1).getToType().prettyPrint();
+  }
+  eq SendTypeEndpointDefinition.targetTypeName() {
+    return getMappingList().isEmpty() ?
+           getType().getTypeDecl().getName() :
+           getMappingList().get(getMappingList().size() - 1).getToType().prettyPrint();
   }
+
 //  eq ReceiveFromRestDefinition.suitableDefaultMapping() {
 //    String typeName = getMappingList().isEmpty() ?
 //        getToken().getJavaTypeUse().getName() :
@@ -236,8 +297,10 @@ aspect Mappings {
   // --- allMappingDefinitions ---
   syn java.util.List<MappingDefinition> RagConnect.allMappingDefinitions() {
     java.util.List<MappingDefinition> result = new java.util.ArrayList<>();
+    // user-defined mappings
     getMappingDefinitionList().iterator().forEachRemaining(result::add);
-    // byte[] conversion
+    // byte[] <-> primitive conversion
+    result.add(defaultBytesToBooleanMapping());
     result.add(defaultBytesToIntMapping());
     result.add(defaultBytesToShortMapping());
     result.add(defaultBytesToLongMapping());
@@ -245,6 +308,7 @@ aspect Mappings {
     result.add(defaultBytesToDoubleMapping());
     result.add(defaultBytesToCharMapping());
     result.add(defaultBytesToStringMapping());
+    result.add(defaultBooleanToBytesMapping());
     result.add(defaultIntToBytesMapping());
     result.add(defaultShortToBytesMapping());
     result.add(defaultLongToBytesMapping());
@@ -252,13 +316,20 @@ aspect Mappings {
     result.add(defaultDoubleToBytesMapping());
     result.add(defaultCharToBytesMapping());
     result.add(defaultStringToBytesMapping());
+    // byte[] <-> tree conversion
+    for (TypeDecl typeDecl : getProgram().typeDecls()) {
+      result.add(defaultBytesToTreeMapping(typeDecl.getName()));
+      result.add(defaultTreeToBytesMapping(typeDecl.getName()));
+    }
 //    // string conversion
+//    result.add(defaultStringToBooleanMapping());
 //    result.add(defaultStringToIntMapping());
 //    result.add(defaultStringToShortMapping());
 //    result.add(defaultStringToLongMapping());
 //    result.add(defaultStringToFloatMapping());
 //    result.add(defaultStringToDoubleMapping());
 //    result.add(defaultStringToCharMapping());
+//    result.add(defaultBooleanToStringMapping());
 //    result.add(defaultIntToStringMapping());
 //    result.add(defaultShortToStringMapping());
 //    result.add(defaultLongToStringMapping());

ragconnect.base/src/main/jastadd/intermediate/MustacheNodes.relast

-MRagConnect ::= ReceiveDefinition:MReceiveDefinition* SendDefinition:MSendDefinition* MappingDefinition:MMappingDefinition* DependencyDefinition:MDependencyDefinition* RootTypeComponent:MTypeComponent* TokenComponent:MTokenComponent* Handler:MHandler*;
+MRagConnect ::= TokenReceiveDefinition:MTokenReceiveDefinition* TokenSendDefinition:MTokenSendDefinition* TypeReceiveDefinition:MTypeReceiveDefinition* TypeSendDefinition:MTypeSendDefinition* MappingDefinition:MMappingDefinition* DependencyDefinition:MDependencyDefinition* RootTypeComponent:MTypeComponent* TokenComponent:MTokenComponent* Handler:MHandler*;
+
 abstract MEndpointDefinition ::= InnerMappingDefinition:MInnerMappingDefinition*;
-MReceiveDefinition : MEndpointDefinition;
-MSendDefinition : MEndpointDefinition;
+abstract MTokenEndpointDefinition : MEndpointDefinition;
+MTokenReceiveDefinition : MTokenEndpointDefinition;
+MTokenSendDefinition : MTokenEndpointDefinition;
+abstract MTypeEndpointDefinition : MEndpointDefinition;
+MTypeReceiveDefinition : MTypeEndpointDefinition;
+MTypeSendDefinition : MTypeEndpointDefinition;
+
 MMappingDefinition;
 MInnerMappingDefinition;
 MDependencyDefinition;
@@ -11,8 +17,10 @@ MHandler ::= <ClassName> <Construction> <AttributeName> <FieldName> <InUse:boole
 
 rel MRagConnect.RagConnect -> RagConnect;
 rel MInnerMappingDefinition.MMappingDefinition -> MMappingDefinition;
-rel MReceiveDefinition.ReceiveTokenEndpointDefinition -> ReceiveTokenEndpointDefinition;
-rel MSendDefinition.SendTokenEndpointDefinition -> SendTokenEndpointDefinition;
+rel MTokenReceiveDefinition.ReceiveTokenEndpointDefinition -> ReceiveTokenEndpointDefinition;
+rel MTokenSendDefinition.SendTokenEndpointDefinition -> SendTokenEndpointDefinition;
+rel MTypeReceiveDefinition.ReceiveTypeEndpointDefinition -> ReceiveTypeEndpointDefinition;
+rel MTypeSendDefinition.SendTypeEndpointDefinition -> SendTypeEndpointDefinition;
 rel MMappingDefinition.MappingDefinition -> MappingDefinition;
 rel MDependencyDefinition.DependencyDefinition -> DependencyDefinition;
 rel MTypeComponent.TypeComponent -> TypeComponent;

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

@@ -25,19 +25,33 @@ aspect MustacheNodesToYAML {
     root.put("restHandlerField", restHandlerField());
     root.put("restHandlerAttribute", restHandlerAttribute());
 
-    // ReceiveDefinitions
+    // TokenReceiveDefinitions
     ListElement receiveDefinitions = new ListElement();
-    for (MReceiveDefinition def : getReceiveDefinitionList()) {
+    for (MTokenReceiveDefinition def : getTokenReceiveDefinitionList()) {
       receiveDefinitions.addElement(def.toYAML());
     }
-    root.put("ReceiveDefinitions", receiveDefinitions);
+    root.put("TokenReceiveDefinitions", receiveDefinitions);
 
-    // SendDefinitions
+    // TokenSendDefinitions
     ListElement sendDefinitions = new ListElement();
-    for (MSendDefinition def : getSendDefinitionList()) {
+    for (MTokenSendDefinition def : getTokenSendDefinitionList()) {
       sendDefinitions.addElement(def.toYAML());
     }
-    root.put("SendDefinitions", sendDefinitions);
+    root.put("TokenSendDefinitions", sendDefinitions);
+
+    // TypeReceiveDefinitions
+    ListElement typeReceiveDefinitions = new ListElement();
+    for (MTypeReceiveDefinition def : getTypeReceiveDefinitionList()) {
+      typeReceiveDefinitions.addElement(def.toYAML());
+    }
+    root.put("TypeReceiveDefinitions", typeReceiveDefinitions);
+
+    // TypeSendDefinitions
+    ListElement typeSendDefinitions = new ListElement();
+    for (MTypeSendDefinition def : getTypeSendDefinitionList()) {
+      typeSendDefinitions.addElement(def.toYAML());
+    }
+    root.put("TypeSendDefinitions", typeSendDefinitions);
 
     // MappingDefinitions
     ListElement mappingDefinitions = new ListElement();
@@ -88,13 +102,30 @@ aspect MustacheNodesToYAML {
     return result;
   }
 
-  syn MappingElement MReceiveDefinition.toYAML() {
+  syn MappingElement MTokenReceiveDefinition.toYAML() {
+    MappingElement result = super.toYAML();
+    result.put("loggingEnabledForReads", loggingEnabledForReads);
+    return result;
+  }
+
+  syn MappingElement MTokenSendDefinition.toYAML() {
+    MappingElement result = super.toYAML();
+    result.put("sender", sender());
+    result.put("lastValue", lastValue());
+    result.put("loggingEnabledForWrites", loggingEnabledForWrites);
+    result.put("updateMethod", updateMethod());
+    result.put("writeMethod", writeMethod());
+    result.put("tokenResetMethod", tokenResetMethod());
+    return result;
+  }
+
+  syn MappingElement MTypeReceiveDefinition.toYAML() {
     MappingElement result = super.toYAML();
     result.put("loggingEnabledForReads", loggingEnabledForReads);
     return result;
   }
 
-  syn MappingElement MSendDefinition.toYAML() {
+  syn MappingElement MTypeSendDefinition.toYAML() {
     MappingElement result = super.toYAML();
     result.put("sender", sender());
     result.put("lastValue", lastValue());