begin with removing tree and list

- renamed useList to isIndexBasedList (flipped semantics)
- fixed readme of test singeList

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

@@ -13,7 +13,7 @@ rel TokenEndpointDefinition.Token <-> TokenComponent.TokenEndpointDefinition*;
 ReceiveTokenEndpointDefinition : TokenEndpointDefinition;
 SendTokenEndpointDefinition : TokenEndpointDefinition;
 
-abstract TypeEndpointDefinition : EndpointDefinition ::= <UseList:boolean> ;
+abstract TypeEndpointDefinition : EndpointDefinition ::= <IndexBasedListAccess:boolean> ;
 rel TypeEndpointDefinition.Type <-> TypeComponent.TypeEndpointDefinition*;
 
 ReceiveTypeEndpointDefinition : TypeEndpointDefinition ::= <WithAdd:boolean>;

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

@@ -124,10 +124,10 @@ aspect AttributesForMustache {
 
   // --- MTypeEndpointDefinition ---
   syn boolean MTypeEndpointDefinition.isWithAdd() = endpointDef().isReceiveTypeEndpointDefinition() ? endpointDef().asReceiveTypeEndpointDefinition().getWithAdd() : false;
-  syn boolean MTypeEndpointDefinition.isUseList() = endpointDef().asTypeEndpointDefinition().getUseList();
+  syn boolean MTypeEndpointDefinition.isIndexBasedListAccess() = endpointDef().asTypeEndpointDefinition().getIndexBasedListAccess();
   eq MTypeEndpointDefinition.getterMethod() = "get" + typeName() + (typeIsList() ? "List" : "");
   eq MTypeEndpointDefinition.parentTypeName() = type().containingTypeDecl().getName();
-  eq MTypeEndpointDefinition.entityName() = typeName() + (isUseList() ? "List" : "");
+  eq MTypeEndpointDefinition.entityName() = typeName() + (typeIsList() && !isIndexBasedListAccess() ? "List" : "");
 
   // --- MInnerMappingDefinition ---
   inh boolean MInnerMappingDefinition.isLast();
@@ -398,7 +398,7 @@ aspect GrammarGeneration {
 
   syn TokenComponent EndpointDefinition.getTokenToCreate() = null;
   eq TypeEndpointDefinition.getTokenToCreate() {
-    if (typeIsList() && !getUseList()) {
+    if (typeIsList() && getIndexBasedListAccess()) {
       TokenComponent result = new TokenComponent();
       result.setName(idTokenName());
       result.setNTA(false);

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

@@ -220,7 +220,7 @@ aspect Mappings {
   eq TypeEndpointDefinition.suitableReceiveDefaultMapping() {
     try {
       TypeDecl typeDecl = program().resolveTypeDecl(targetTypeName());
-      return typeIsList() && getUseList() ? ragconnect().defaultBytesToListTreeMapping(typeDecl.getName()) : ragconnect().defaultBytesToTreeMapping(typeDecl.getName());
+      return typeIsList() && !getIndexBasedListAccess() ? ragconnect().defaultBytesToListTreeMapping(typeDecl.getName()) : ragconnect().defaultBytesToTreeMapping(typeDecl.getName());
     } catch (Exception ignore) {}
     return super.suitableReceiveDefaultMapping();
   }
@@ -256,7 +256,7 @@ aspect Mappings {
   eq TypeEndpointDefinition.suitableSendDefaultMapping() {
     try {
       TypeDecl typeDecl = program().resolveTypeDecl(targetTypeName());
-      return typeIsList() && getUseList() ? ragconnect().defaultListTreeToBytesMapping() : ragconnect().defaultTreeToBytesMapping(typeDecl.getName());
+      return typeIsList() && !getIndexBasedListAccess() ? ragconnect().defaultListTreeToBytesMapping() : ragconnect().defaultTreeToBytesMapping(typeDecl.getName());
     } catch (Exception ignore) {}
     return super.suitableSendDefaultMapping();
   }

ragconnect.base/src/main/jastadd/parser/ParserRewrites.jrag

@@ -4,9 +4,7 @@ aspect ParserRewrites {
     to SendTypeEndpointDefinition {
       SendTypeEndpointDefinition result = new SendTypeEndpointDefinition();
       result.applyFrom(this);
-      if (this.getIndexed()) {
-        result.setUseList(true);
-      }
+      result.setIndexBasedListAccess(this.getIndexed());
       return result;
     }
   }
@@ -16,12 +14,8 @@ aspect ParserRewrites {
     to ReceiveTypeEndpointDefinition {
       ReceiveTypeEndpointDefinition result = new ReceiveTypeEndpointDefinition();
       result.applyFrom(this);
-      if (this.getWithAdd()) {
-        result.setWithAdd(true);
-      }
-      if (this.getIndexed()) {
-        result.setUseList(true);
-      }
+      result.setWithAdd(this.getWithAdd());
+      result.setIndexBasedListAccess(this.getIndexed());
       return result;
     }
   }

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

 {{#typeIsList}}
-{{^UseList}}
+{{#IndexBasedListAccess}}
 private int {{parentTypeName}}.{{resolveInListMethodName}}(String topic) {
   for (int index = 0; index < getNum{{entityName}}(); index++) {
     if (get{{entityName}}(index).get{{idTokenName}}().equals(topic)) {
@@ -8,7 +8,7 @@ private int {{parentTypeName}}.{{resolveInListMethodName}}(String topic) {
   }
   return -1;
 }
-{{/UseList}}
+{{/IndexBasedListAccess}}
 {{/typeIsList}}
 
 /**
@@ -17,13 +17,13 @@ private int {{parentTypeName}}.{{resolveInListMethodName}}(String topic) {
  * New values are appended to the end of the list.
 {{/isWithAdd}}{{/typeIsList}}
  * @param {{connectParameterName}} string describing protocol and path as an URI
-{{#typeIsList}}{{^UseList}}{{^isWithAdd}}
+{{#typeIsList}}{{#IndexBasedListAccess}}{{^isWithAdd}}
  * @param index index of node in list to connect (the list is expected to have enough elements)
-{{/isWithAdd}}{{/UseList}}{{/typeIsList}}
+{{/isWithAdd}}{{/IndexBasedListAccess}}{{/typeIsList}}
  * @return true if connect was successful, false otherwise
  * @throws java.io.IOException if connect failed
  */
-public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterName}}{{#typeIsList}}{{^UseList}}{{^isWithAdd}}, int index{{/isWithAdd}}{{/UseList}}{{/typeIsList}}) throws java.io.IOException {
+public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterName}}{{#typeIsList}}{{#IndexBasedListAccess}}{{^isWithAdd}}, int index{{/isWithAdd}}{{/IndexBasedListAccess}}{{/typeIsList}}) throws java.io.IOException {
   java.util.function.BiConsumer<String, byte[]> consumer = (topic, message) -> {
     {{> mappingApplication}}
 {{#loggingEnabledForReads}}
@@ -32,15 +32,15 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
 {{#isTypeEndpointDefinition}}
     {{lastResult}}.treeResolveAll();
  {{#typeIsList}}
-  {{#UseList}}
+  {{^IndexBasedListAccess}}
    {{#isWithAdd}}
     {{getterMethod}}().addAll({{lastResult}});
    {{/isWithAdd}}
    {{^isWithAdd}}
     set{{entityName}}({{lastResult}});
    {{/isWithAdd}}
-  {{/UseList}}
-  {{^UseList}}
+  {{/IndexBasedListAccess}}
+  {{#IndexBasedListAccess}}
     {{lastResult}}.set{{idTokenName}}(topic);
    {{#isWithAdd}}
     {{getterMethod}}().add({{lastResult}});
@@ -48,7 +48,7 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
    {{^isWithAdd}}
     set{{entityName}}({{lastResult}}, index);
    {{/isWithAdd}}
-  {{/UseList}}
+  {{/IndexBasedListAccess}}
  {{/typeIsList}}
  {{^typeIsList}}
     set{{entityName}}({{lastResult}});
@@ -61,7 +61,7 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
   return {{internalConnectMethod}}({{connectParameterName}}, consumer);
 }
 
-{{#typeIsList}}{{^UseList}}{{^isWithAdd}}
+{{#typeIsList}}{{#IndexBasedListAccess}}{{^isWithAdd}}
 /**
  * Connects the receive endpoint {{entityName}} using a "wildcard" URI (if supported by the chosen protocol).
  * @param {{connectParameterName}} string describing protocol and path as an URI
@@ -84,7 +84,7 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
   };
   return {{internalConnectMethod}}({{connectParameterName}}, consumer);
 }
-{{/isWithAdd}}{{/UseList}}{{/typeIsList}}
+{{/isWithAdd}}{{/IndexBasedListAccess}}{{/typeIsList}}
 
 private boolean {{parentTypeName}}.{{internalConnectMethod}}(String {{connectParameterName}},
     java.util.function.BiConsumer<String, byte[]> consumer) throws java.io.IOException {

ragconnect.tests/src/test/01-input/list/Test.connect

-send indexed SenderRoot.A ;
-send indexed SenderRoot.SingleA ;
-receive indexed ReceiverRoot.A ;
-receive indexed ReceiverRoot.FromSingleA ;
-receive indexed with add ReceiverRoot.WithAddFromA ;
-receive indexed with add ReceiverRoot.WithAddFromSingleA ;
+send SenderRoot.A ;
+send SenderRoot.SingleA ;
+receive ReceiverRoot.A ;
+receive ReceiverRoot.FromSingleA ;
+receive with add ReceiverRoot.WithAddFromA ;
+receive with add ReceiverRoot.WithAddFromSingleA ;

ragconnect.tests/src/test/01-input/singleList/README.md

@@ -18,7 +18,7 @@ SenderRoot                         ReceiverRoot
 
 ## Computation
 
-A _n_ = Input _n_ + 1, e.g., A1 = Input1 + 1
+A _n_ = Input _n_ + _n_, e.g., A1 = Input1 + 1 and A3 = Input3 + 3
 
 ## Execution-Trace (SendInitialValue)
 

ragconnect.tests/src/test/01-input/singleList/Test.connect

@@ -4,10 +4,10 @@ send SenderRoot.A3 ;
 send SenderRoot.A4 ;
 send SenderRoot.InOutput using IntToA ;
 
-receive ReceiverRoot.A ;
-receive ReceiverRoot.UsingWildcardA ;
-receive with add ReceiverRoot.WithAddA ;
-receive with add ReceiverRoot.UsingWildcardWithAddA ;
+receive indexed ReceiverRoot.A ;
+receive indexed ReceiverRoot.UsingWildcardA ;
+receive indexed with add ReceiverRoot.WithAddA ;
+receive indexed with add ReceiverRoot.UsingWildcardWithAddA ;
 
 IntToA maps int i to A {:
     return new A().setID(i);