diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 401f721305affd0b14d18923027c42dd32c6edfb..7d2d228dd2679f49968e6404f3ee101de703eb00 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -117,7 +117,7 @@ pages-dry-run:
- dev
- master
-pages-master:
+pages:
extends: .pages-template
artifacts:
paths:
diff --git a/pages/docs/changelog.md b/pages/docs/changelog.md
index 1f41f95d1e11cb361d9d4e4b3675d20e09e575fe..450dbc1ac84cb0b038abbdc1d081fba315f0da76 100644
--- a/pages/docs/changelog.md
+++ b/pages/docs/changelog.md
@@ -4,9 +4,9 @@
### Changes
-- Allow connection endpoints for relations ([#37](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/37)) and attributes ([#38](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/38))
-- Allow send connection endpoints non-NTA nonterminals ([#36](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/36))
-- Allow context-free context endpoints ([#34](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/34))
+- Allow connection ports for relations ([#37](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/37)) and attributes ([#38](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/38))
+- Allow send connection ports non-NTA nonterminals ([#36](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/36))
+- Allow context-free context ports ([#34](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/34))
- Experimental support for Java handler ([#52](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/52))
- Make specification language more concise ([#33](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/33))
@@ -17,24 +17,24 @@
## 0.3.2
-- Allow connection endpoints for list nonterminals ([#21](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/21))
+- Allow connection ports for list nonterminals ([#21](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/21))
- Ensure correct connect and disconnect functionality ([#31](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/31))
- Enhance documentation ([#13](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/13), [#20](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/20), [#41](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/41))
## 0.3.1
- Full support for incremental dependency tracking
-- Full support for subtree endpoint definitions ([#9](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/9))
+- Full support for subtree port definitions ([#9](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/9))
- Internal: Use updated gradle plugin for tests ([#18](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/18))
-- Bugfix [#22](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/22): Correct handling of malformed URIs passed when connecting an endpoint
-- Bugfix [#23](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/23): Correct handling of OptComponents as endpoints
+- Bugfix [#22](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/22): Correct handling of malformed URIs passed when connecting an port
+- Bugfix [#23](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/23): Correct handling of OptComponents as ports
- Bugfix [#27](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/27): Correctly handle whitespaces in grammars
## 0.3.0
- Added [API documentation](ragdoc/index.html) to documentation
-- Add methods to `disconnect` an endpoint
-- Internal: PoC for incremental dependency tracking and subtree endpoint definitions ([#14](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/14))
+- Add methods to `disconnect` a port
+- Internal: PoC for incremental dependency tracking and subtree port definitions ([#14](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/14))
- Bugfix [#17](https://git-st.inf.tu-dresden.de/jastadd/ragconnect/-/issues/17): Added missing support for `boolean`
## 0.2.2
diff --git a/pages/docs/compiler.md b/pages/docs/compiler.md
index 3638757c78a1624bff4b94407d006a2636751884..e89ad8fc8169e084c97736d6447c3466f1e2bc27 100644
--- a/pages/docs/compiler.md
+++ b/pages/docs/compiler.md
@@ -90,9 +90,9 @@ However, depending on the selected protocols and/or used features, additional de
- JastAdd version has to support `INC_FLUSH_START` and `INC_FLUSH_END` (i.e., has [issue #329][jastadd-issue-329] resolved)
- [Feature description](using.md#dependency-tracking-automatically-derived)
-### Tree/List Endpoints
+### Tree/List Ports
-- Condition: When using endpoints along with default mappings for subtrees
+- Condition: When using ports along with default mappings for subtrees
- Required runtime dependencies:
- `group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.12.1'`
- `group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.1'`
diff --git a/pages/docs/dsl.md b/pages/docs/dsl.md
index 3451c43f32ba18d6af90d8f201fd0aa366d18817..6776c0449cce0a903cab11c8f9fa061fef04045e 100644
--- a/pages/docs/dsl.md
+++ b/pages/docs/dsl.md
@@ -3,14 +3,14 @@
# The RagConnect Specification Language
-To declare endpoints and mappings, a domain-specific language ([DSL](https://en.wikipedia.org/wiki/Domain-specific_language)) is used.
+To declare ports and mappings, a domain-specific language ([DSL](https://en.wikipedia.org/wiki/Domain-specific_language)) is used.
-## Endpoints
+## Ports
-An endpoint marks an element of an AST as sending or receiving element.
-The kind of the element determines, whether an endpoint for it can be receiving, sending, or both at the same time.
+A port marks an element of an AST as sending or receiving element.
+The kind of the element determines, whether an port for it can be receiving, sending, or both at the same time.
-To declare a new endpoints, use the following syntax:
+To declare a new ports, use the following syntax:
```
("send"|"receive") ["indexed"] ["with add"] <Non-Terminal>[.<Target>["(<AttributeType>)"]] ["using" <Mapping-Name> (, <Mapping-Name>)*] ";"
@@ -18,34 +18,34 @@ To declare a new endpoints, use the following syntax:
A breakdown of the parts of that syntax:
-- The first word (`send` or `receive`) defines the kind of endpoint - sending or receiving, respectively.
-- The optional `indexed` applies only for list children and lets the endpoint act on elements of that list.
- This only works for receiving endpoints, and is further changed by `with add`.
+- The first word (`send` or `receive`) defines the kind of port - sending or receiving, respectively.
+- The optional `indexed` applies only for list children and lets the port act on elements of that list.
+ This only works for receiving ports, and is further changed by `with add`.
- A lonely `indexed` assigns each incoming "topic" to an index in a list.
- This can be useful if multiple instances of this endpoint are connected, or the communication protocol supports wildcard topics.
+ This can be useful if multiple instances of this port are connected, or the communication protocol supports wildcard topics.
For the former case, the connect method with an explicit index can be used, whereas the "normal" connect method without the index acts as a method for "wildcard-connect".
- Combining `indexed with add`, incoming data is required to be an element of the list, and will be appended to the list.
-- The second optional keyword `with add` can also be used only for receiving endpoints targeting a list children.
+- The second optional keyword `with add` can also be used only for receiving ports targeting a list children.
As described above, it can be combined with `indexed`.
If used on its own, the incoming data is interpreted as a complete list and its elements will be appended to the current list.
- The `<Non-Terminal>[.<Target>["(<AttributeType>)"]]` notation describes the actual affected node.
- - If the target is omitted, all nodes of that non-terminal type can be connected, irrespective of their context. This is a context-free endpoint definition.
+ - If the target is omitted, all nodes of that non-terminal type can be connected, irrespective of their context. This is a context-free port definition.
- The target can be any child on the right-hand side of a production rule, a role of a relation, or an attribute.
The brackets `(<AttributeType>)` after the target must be used in case of an attribute, and only then.
Here, the return type of the attribute has to be specified, as aspect files are not parsed by RagConnect.
Hence, RagConnect can not and will not verify the existence of the attribute, and the possible non-existence of an attribute will be found by the Java compiler.
-- Optionally, an endpoint can use one or more [mappings](#mappings).
+- Optionally, a port can use one or more [mappings](#mappings).
They will be applied before sending, or after receiving a message.
Mappings will always be applied in the order they are listed after `using`.
-### Context-Free Endpoints
+### Context-Free Ports
-An endpoint with only a non-terminal and without a target is called context-free endpoint.
-Specifying such an endpoint has several consequences:
+A port with only a non-terminal and without a target is called context-free port.
+Specifying such a port has several consequences:
-- The given non-terminal can be connected to in all contexts it occurs as if there were endpoints for all those contexts.
+- The given non-terminal can be connected to in all contexts it occurs as if there were ports for all those contexts.
- There is a special method available on the given non-terminal to connect itself, which selects the correct connect-method depending on its context.
-- Context-sensitive endpoints for this non-terminal can still be specified to modify mappings in this context. If the context is a list, the endpoint must use `indexed` and cannot use `with add`.
+- Context-sensitive ports for this non-terminal can still be specified to modify mappings in this context. If the context is a list, the port must use `indexed` and cannot use `with add`.
**Example**:
@@ -56,7 +56,7 @@ A ::= <Value> ;
// connect
receive A;
-receive Root.SingleA using MyMapping; // specialized endpoint
+receive Root.SingleA using MyMapping; // specialized port
```
Implied, additional connect specifications:
@@ -79,8 +79,8 @@ root.connectOptA("<some-uri-to-connect>");
## Mappings
-A mapping is a side effect-free function with one argument (the value that will be transformed) and one result (the transformed value), that will be applied on a value to be sent for a sending endpoint, a received value for a receiving endpoint, or the result of another mapping.
-Mappings can be shared between endpoints.
+A mapping is a side effect-free function with one argument (the value that will be transformed) and one result (the transformed value), that will be applied on a value to be sent for a sending port, a received value for a receiving port, or the result of another mapping.
+Mappings can be shared between ports.
To declare a mapping, use the following syntax:
@@ -93,16 +93,16 @@ To declare a mapping, use the following syntax:
A breakdown of the parts of that syntax:
- The `<Mapping-Name>` identifies the mapping.
-- The `<From-Type` is the type of the input. The type of the first mapping of a receiving endpoint must be `byte[]`.
+- The `<From-Type` is the type of the input. The type of the first mapping of a receiving port must be `byte[]`.
- To refer to the input, `<Input-Variable-Name>` defines the name of it.
-- The `<To-Type>` is the type of the result. The type of the last mapping of a sending endpoint must be `byte[]`.
+- The `<To-Type>` is the type of the result. The type of the last mapping of a sending port must be `byte[]`.
- Finally, the `<Java-Block>` is the actual definition of the mapping using normal Java syntax.
The previously defined input variable can be used via its name here.
This block can contain multiple statements, but must end with a `return` statement.
The validity of this block is not verified by RagConnect itself, but later in the compilation process by the Java compiler.
Note: There are default mappings provided for all primitive Java types (using their "normal" byte representation), and for all non-terminal types (using their JSON representation converted from/to bytes).
-Those default mappings apply to both sending and receiving endpoints, and match their counterparts, e.g., the mapping from `int` to `byte[]` uses the same byte representation as the mapping back from `byte[]` to `int`.
+Those default mappings apply to both sending and receiving ports, and match their counterparts, e.g., the mapping from `int` to `byte[]` uses the same byte representation as the mapping back from `byte[]` to `int`.
Default mappings are always inserted if either no mapping is present, or if the type of the first/last mapping is not `byte[]` as stated above.
Their main intent is to allow quick prototyping without constraining a more complex use case.
@@ -112,7 +112,7 @@ Their main intent is to allow quick prototyping without constraining a more comp
Deprecated since `1.0.0`
A dependency definition describes a possible dependency on type-level from a token to an attribute.
-Whenever the token changes, the attribute is eagerly re-computed and endpoints attached to it are triggered.
+Whenever the token changes, the attribute is eagerly re-computed and ports attached to it are triggered.
Such a dependency must be added on instance-level for every token that could have an influence to the attribute.
An alternative for those explicit dependency definitions is [incremental dependency tracking](using.md#dependency-tracking-automatically-derived).
diff --git a/pages/docs/inner-workings.md b/pages/docs/inner-workings.md
index 1cb22a597804d2a67a6f05c0181f4b7c359644ee..101692e9dedfe11a1bbd2e039c7fb1bbc5429930 100644
--- a/pages/docs/inner-workings.md
+++ b/pages/docs/inner-workings.md
@@ -6,13 +6,13 @@ Please see [API documentation](ragdoc/index.html) for more details.
`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.
+It further uses a dedicated parser for `.connect` files containing port-, mapping-, and dependency-definitions.
This results in an ASTNode of type `RagConnect`.
-The goal is to generate an aspect file containing setters and getters of tokens referred to by endpoint-definitions
+The goal is to generate an aspect file containing setters and getters of tokens referred to by port-definitions
We use [mustache](https://mustache.github.io/) (currently its [Java version](https://github.com/spullara/mustache.java)) making use of partials to separate concerns.
The `.mustache` files are located in `ragconnect.base/src/main/resources`.
The generation process uses intermediates NTAs (whose types are defined in `Intermediate.relast`) to ease the definition of two main generation "problems".
-Those problems are differentiation on both kinds of an endpoint (send/receive and type/token/list), and attributes depending on position in n-ary relations.
+Those problems are differentiation on both kinds of a port (send/receive and type/token/list), and attributes depending on position in n-ary relations.
There are aspect files for `Navigation` (mainly isX/asX attributes), `Analysis` (static analysis attributes), `Printing`, `Mappings` (default mappings).
One of the main aspects is `Intermediate` containing all attributes consumed by `mustache` and other attributes the former depend on.
@@ -26,7 +26,7 @@ In the following, details for special implementation topics are discussed.
## Forwarding
-When a nonterminal is used in a send endpoints, it needs an implicit forwarding attribute to work, because only _computed elements_ can be sent.
+When a nonterminal is used in a send ports, it needs an implicit forwarding attribute to work, because only _computed elements_ can be sent.
Since the nonterminal itself should be sent, the generated attribute simply returns this nonterminal.
However, changing any token within the whole subtree or changing the structure of the subtree must trigger a new message, upon computation of the forwarding attribute, all tokens are "touched" (their getter is called).
diff --git a/pages/docs/using.md b/pages/docs/using.md
index 3db759d61abfb9995e31a661c2573fec86540677..e9705465ab851344f0abda19acd75e1cad334cb4 100644
--- a/pages/docs/using.md
+++ b/pages/docs/using.md
@@ -17,7 +17,7 @@ B ::= <OutputOnB:String> ;
To declare receiving and sending tokens, a dedicated DSL is used:
```java
-// endpoint definitions
+// port definitions
receive A.Input ;
send A.OutputOnA ;
send B.OutputOnB using Transformation ;
@@ -101,11 +101,11 @@ The first parameter of those connect-methods is always a URI-like String, to ide
In case of MQTT, the server is the host running an MQTT broker, and the path is equal to the topic to publish or subscribe to.
Please note, that the first leading slash (`/`) is removed for MQTT topics, e.g., for `A.Input` the topic is actually `topic/for/input`.
-For sending endpoints, there is a second boolean parameter to specify whether the current value shall be sent immediately after connecting.
+For sending ports, there is a second boolean parameter to specify whether the current value shall be sent immediately after connecting.
## Remarks for using manual dependency tracking
-When constructing the AST and connecting it, one should always set dependencies before connecting, especially if updates already arriving for receiving endpoints.
+When constructing the AST and connecting it, one should always set dependencies before connecting, especially if updates already arriving for receiving ports.
Otherwise, updates might not be propagated after setting dependencies, if values are equal after applying transformations of mapping definitions.
As an example, when using the following grammar and definitions for RagConnect ...
@@ -129,7 +129,7 @@ Round maps float f to int {:
# An advanced example
-Non-terminal children can also be selected as endpoints (not only tokens).
+Non-terminal children can also be selected as ports (not only tokens).
## Normal Non-Terminal Children
@@ -156,7 +156,7 @@ receive ReceiverRoot.A ;
To process non-terminals, default mappings are provided for every non-terminal type of the used grammar.
They use the JSON serialization offered by the RelAST compiler, i.e., interpret the message as a `String`, deserialize the content reading the message as JSON, or vice versa.
-Additional dependencies are required to use this feature, as detailed in [the compiler section](compiler.md#treelist-endpoints).
+Additional dependencies are required to use this feature, as detailed in [the compiler section](compiler.md#treelist-ports).
## Receiving List Children
@@ -173,7 +173,7 @@ Several options are possible (please also refer to the specification of the [con
### (empty)
-A message for a list endpoint can be interpreted as a complete list (a sequence of nodes of type `A`) by not specifying any special keyword:
+A message for a list port can be interpreted as a complete list (a sequence of nodes of type `A`) by not specifying any special keyword:
```
receive ReceiverRoot.A ;
@@ -190,7 +190,7 @@ receive with add ReceiverRoot.Alfa ;
### indexed
-A message for a list endpoint can also be interpreted as an element of this list.
+A message for a list port can also be interpreted as an element of this list.
```
receive tree ReceiverRoot.A ;
@@ -245,10 +245,10 @@ assertEquals(receiverRoot.getAList(), list("1", "other"));
assertEquals(receiverRoot.getAList(), list("1", "other", "new"));
```
-## Using attributes as endpoint targets
+## Using attributes as port targets
-As described in the [DSL specification](dsl.md), attributes can be used as endpoint targets.
-They can only be used in send endpoints, and the return type of the attribute must be specified in the connect specification (because aspect files are not handled completely yet).
+As described in the [DSL specification](dsl.md), attributes can be used as port targets.
+They can only be used in send ports, and the return type of the attribute must be specified in the connect specification (because aspect files are not handled completely yet).
Currently, synthesized, inherited, collection, and circular attributes are supported.
Nonterminal attributes are best used with the "legacy" notation `/Context:Type/` within the grammar.
diff --git a/ragconnect.base/src/main/jastadd/Analysis.jrag b/ragconnect.base/src/main/jastadd/Analysis.jrag
index 4baff8e5763af0b3a1c8870fa1d2b0a935bb9a24..79f37b38b3839982f784f1dd79b094a663aaa921 100644
--- a/ragconnect.base/src/main/jastadd/Analysis.jrag
+++ b/ragconnect.base/src/main/jastadd/Analysis.jrag
@@ -1,13 +1,13 @@
aspect Analysis {
// --- isAlreadyDefined ---
- syn boolean EndpointDefinition.isAlreadyDefined() = getEndpointTarget().isAlreadyDefined();
- syn boolean EndpointTarget.isAlreadyDefined();
- eq AttributeEndpointTarget.isAlreadyDefined() {
+ syn boolean PortDefinition.isAlreadyDefined() = getPortTarget().isAlreadyDefined();
+ syn boolean PortTarget.isAlreadyDefined();
+ eq AttributePortTarget.isAlreadyDefined() {
// define lookup here, as not used elsewhere
int numberOfSameDefs = 0;
- for (EndpointTarget target : ragconnect().givenEndpointTargetList()) {
- if (target.isAttributeEndpointTarget()) {
- AttributeEndpointTarget other = target.asAttributeEndpointTarget();
+ for (PortTarget target : ragconnect().givenPortTargetList()) {
+ if (target.isAttributePortTarget()) {
+ AttributePortTarget other = target.asAttributePortTarget();
if (other.getParentTypeDecl().equals(this.getParentTypeDecl()) && other.getName().equals(this.getName())) {
numberOfSameDefs += 1;
}
@@ -15,12 +15,12 @@ aspect Analysis {
}
return numberOfSameDefs > 1;
}
- eq RelationEndpointTarget.isAlreadyDefined() {
+ eq RelationPortTarget.isAlreadyDefined() {
// define lookup here, as not used elsewhere
int numberOfSameDefs = 0;
- for (EndpointTarget target : ragconnect().givenEndpointTargetList()) {
- if (target.isRelationEndpointTarget()) {
- RelationEndpointTarget other = target.asRelationEndpointTarget();
+ for (PortTarget target : ragconnect().givenPortTargetList()) {
+ if (target.isRelationPortTarget()) {
+ RelationPortTarget other = target.asRelationPortTarget();
if (other.getRole().equals(this.getRole())) {
numberOfSameDefs += 1;
}
@@ -28,25 +28,25 @@ aspect Analysis {
}
return numberOfSameDefs > 1;
}
- eq TokenEndpointTarget.isAlreadyDefined() {
- return lookupTokenEndpointDefinitions(getToken()).stream()
- .filter(containingEndpointDefinition()::matchesType)
+ eq TokenPortTarget.isAlreadyDefined() {
+ return lookupTokenPortDefinitions(getToken()).stream()
+ .filter(containingPortDefinition()::matchesType)
.count() > 1;
}
- eq TypeEndpointTarget.isAlreadyDefined() {
- return lookupGivenTypeEndpointDefinitions(getType()).stream()
- .filter(containingEndpointDefinition()::matchesType)
+ eq TypePortTarget.isAlreadyDefined() {
+ return lookupGivenTypePortDefinitions(getType()).stream()
+ .filter(containingPortDefinition()::matchesType)
.count() > 1;
}
- eq ContextFreeTypeEndpointTarget.isAlreadyDefined() {
- return lookupContextFreeTypeEndpointDefinitions(getTypeDecl()).stream()
- .filter(containingEndpointDefinition()::matchesType)
+ eq ContextFreeTypePortTarget.isAlreadyDefined() {
+ return lookupContextFreeTypePortDefinitions(getTypeDecl()).stream()
+ .filter(containingPortDefinition()::matchesType)
.count() > 1;
}
syn boolean DependencyDefinition.isAlreadyDefined() = lookupDependencyDefinition(getSource().containingTypeDecl(), getID()) != this;
// --- matchesType ---
- syn boolean EndpointDefinition.matchesType(EndpointDefinition other) = this.getSend() == other.getSend();
+ syn boolean PortDefinition.matchesType(PortDefinition other) = this.getSend() == other.getSend();
// --- assignableTo ---
syn boolean MappingDefinitionType.assignableTo(JavaTypeUse target);
@@ -90,24 +90,24 @@ aspect Analysis {
}
}
- syn boolean EndpointTarget.hasAttributeResetMethod();
- eq AttributeEndpointTarget.hasAttributeResetMethod() = false;
- eq RelationEndpointTarget.hasAttributeResetMethod() = false;
- eq TokenEndpointTarget.hasAttributeResetMethod() = getToken().getNTA();
- eq TypeEndpointTarget.hasAttributeResetMethod() = getType().getNTA();
- eq ContextFreeTypeEndpointTarget.hasAttributeResetMethod() = false;
+ syn boolean PortTarget.hasAttributeResetMethod();
+ eq AttributePortTarget.hasAttributeResetMethod() = false;
+ eq RelationPortTarget.hasAttributeResetMethod() = false;
+ eq TokenPortTarget.hasAttributeResetMethod() = getToken().getNTA();
+ eq TypePortTarget.hasAttributeResetMethod() = getType().getNTA();
+ eq ContextFreeTypePortTarget.hasAttributeResetMethod() = false;
// --- needProxyToken ---
syn boolean TokenComponent.needProxyToken() = !getDependencySourceDefinitionList().isEmpty() ||
- getTokenEndpointTargetList().stream()
- .map(EndpointTarget::containingEndpointDefinition)
- .anyMatch(EndpointDefinition::shouldNotResetValue);
+ getTokenPortTargetList().stream()
+ .map(PortTarget::containingPortDefinition)
+ .anyMatch(PortDefinition::shouldNotResetValue);
// --- effectiveUsedAt ---
- coll Set<EndpointDefinition> MappingDefinition.effectiveUsedAt()
- [new java.util.HashSet<EndpointDefinition>()]
+ coll Set<PortDefinition> MappingDefinition.effectiveUsedAt()
+ [new java.util.HashSet<PortDefinition>()]
root RagConnect;
- EndpointDefinition contributes this
+ PortDefinition contributes this
to MappingDefinition.effectiveUsedAt()
for each effectiveMappings();
diff --git a/ragconnect.base/src/main/jastadd/Errors.jrag b/ragconnect.base/src/main/jastadd/Errors.jrag
index 922fbf3dda85efa883706c684fe63a559bc65684..5e15584f2188ce2d52ad74c60444a3be0e27eede 100644
--- a/ragconnect.base/src/main/jastadd/Errors.jrag
+++ b/ragconnect.base/src/main/jastadd/Errors.jrag
@@ -3,45 +3,45 @@ aspect Errors {
[new TreeSet<CompilerMessage>()]
root RagConnect;
- EndpointDefinition contributes error("Endpoint definition already defined for " + parentTypeName() + "." + entityName())
+ PortDefinition contributes error("Port definition already defined for " + parentTypeName() + "." + entityName())
when isAlreadyDefined()
to RagConnect.errors();
- EndpointDefinition contributes error("Receiving target token must not be an NTA token!")
- when !getSend() && getEndpointTarget().isTokenEndpointTarget() && token().getNTA()
+ PortDefinition contributes error("Receiving target token must not be an NTA token!")
+ when !getSend() && getPortTarget().isTokenPortTarget() && token().getNTA()
to RagConnect.errors();
- EndpointDefinition contributes error("Indexed based list access may only be used for type endpoint targets!")
- when getIndexBasedListAccess() && !getEndpointTarget().isTypeEndpointTarget()
+ PortDefinition contributes error("Indexed based list access may only be used for type port targets!")
+ when getIndexBasedListAccess() && !getPortTarget().isTypePortTarget()
to RagConnect.errors();
// if first mapping is null, then suitableDefaultMapping() == null
- EndpointDefinition contributes error("No suitable default mapping found for type " +
+ PortDefinition contributes error("No suitable default mapping found for type " +
((getMappingList().isEmpty())
? token().effectiveJavaTypeUse().prettyPrint()
: getMappingList().get(0).getFromType().prettyPrint()))
- when !getSend() && getEndpointTarget().isTokenEndpointTarget() && effectiveMappings().get(0) == null
+ when !getSend() && getPortTarget().isTokenPortTarget() && effectiveMappings().get(0) == null
to RagConnect.errors();
- EndpointDefinition contributes error("to-type of last mapping (" +
+ PortDefinition contributes error("to-type of last mapping (" +
effectiveMappings().get(effectiveMappings().size() - 1).getToType().prettyPrint() +
") not assignable to type of the token (" + token().effectiveJavaTypeUse().prettyPrint() + ")!")
- when !getSend() && getEndpointTarget().isTokenEndpointTarget() &&
+ when !getSend() && getPortTarget().isTokenPortTarget() &&
!effectiveMappings().get(effectiveMappings().size() - 1).getToType().assignableTo(
token().effectiveJavaTypeUse())
to RagConnect.errors();
- UntypedEndpointTarget contributes error("Could not resolve endpoint target " + getTypeName() + "." + getChildName())
+ UntypedPortTarget contributes error("Could not resolve port target " + getTypeName() + "." + getChildName())
to RagConnect.errors();
- ContextFreeTypeEndpointTarget contributes error("Context-Free endpoint not allowed for root node " +
+ ContextFreeTypePortTarget contributes error("Context-Free port not allowed for root node " +
getTypeDecl().getName() + "!")
when getTypeDecl().occurencesInProductionRules().isEmpty()
to RagConnect.errors();
- EndpointDefinition contributes error("Clash with implied, indexed endpoint definition of context-free endpoint in line " +
- clashingContextFreeEndpointDefinition().getStartLine() + "!")
- when clashingContextFreeEndpointDefinition() != null && clashingContextFreeEndpointDefinition().matchesType(this)
+ PortDefinition contributes error("Clash with implied, indexed port definition of context-free port in line " +
+ clashingContextFreePortDefinition().getStartLine() + "!")
+ when clashingContextFreePortDefinition() != null && clashingContextFreePortDefinition().matchesType(this)
to RagConnect.errors();
DependencyDefinition contributes error("Dependency definition already defined for " + getSource().containingTypeDecl().getName() + " with name " + getID())
@@ -63,14 +63,14 @@ aspect ErrorHelpers {
return false;
}
- syn EndpointDefinition EndpointDefinition.clashingContextFreeEndpointDefinition() {
+ syn PortDefinition PortDefinition.clashingContextFreePortDefinition() {
if (getSend() || !typeIsList() || getIndexBasedListAccess()) {
return null;
}
- List<EndpointDefinition> contextFreeEndpointsWithSameType = lookupContextFreeTypeEndpointDefinitions(
- getEndpointTarget().asTypeEndpointTarget().getType().getTypeDecl());
- if (!contextFreeEndpointsWithSameType.isEmpty()) {
- return contextFreeEndpointsWithSameType.get(0);
+ List<PortDefinition> contextFreePortsWithSameType = lookupContextFreeTypePortDefinitions(
+ getPortTarget().asTypePortTarget().getType().getTypeDecl());
+ if (!contextFreePortsWithSameType.isEmpty()) {
+ return contextFreePortsWithSameType.get(0);
}
return null;
}
diff --git a/ragconnect.base/src/main/jastadd/Intermediate.jadd b/ragconnect.base/src/main/jastadd/Intermediate.jadd
index f025edb56ab84288d464dffce8fa561978cff6d0..97cc5148e9e6901d8a1b23cc965adbd57a7c0d44 100644
--- a/ragconnect.base/src/main/jastadd/Intermediate.jadd
+++ b/ragconnect.base/src/main/jastadd/Intermediate.jadd
@@ -44,12 +44,12 @@ aspect SharedMustache {
syn String RagConnect.rootNodeName() = getConfiguration().getRootNode().getName();
- // === EndpointDefinition ===
- syn String EndpointDefinition.lastResult() = lastDefinition().outputVarName();
+ // === PortDefinition ===
+ syn String PortDefinition.lastResult() = lastDefinition().outputVarName();
- syn boolean EndpointDefinition.typeIsList() = getEndpointTarget().typeIsList();
+ syn boolean PortDefinition.typeIsList() = getPortTarget().typeIsList();
- syn boolean EndpointDefinition.typeIsOpt() = getEndpointTarget().typeIsOpt();
+ syn boolean PortDefinition.typeIsOpt() = getPortTarget().typeIsOpt();
// === attributes needed for computing above ones ===
syn String RagConnect.logStatement(String level) {
@@ -78,12 +78,12 @@ aspect SharedMustache {
return "unknownLoggingOptionGiven_" + getConfiguration().getLoggingTarget() + "_";
}
}
- syn boolean EndpointTarget.typeIsList() = false;
- eq TypeEndpointTarget.typeIsList() = getType().isListComponent();
- eq RelationEndpointTarget.typeIsList() = getRole().isListRole();
+ syn boolean PortTarget.typeIsList() = false;
+ eq TypePortTarget.typeIsList() = getType().isListComponent();
+ eq RelationPortTarget.typeIsList() = getRole().isListRole();
- syn boolean EndpointTarget.typeIsOpt() = false;
- eq TypeEndpointTarget.typeIsOpt() {
+ syn boolean PortTarget.typeIsOpt() = false;
+ eq TypePortTarget.typeIsOpt() {
return getType().isOptComponent();
}
}
@@ -137,20 +137,20 @@ aspect MustacheHandleUri { /* empty */ }
aspect MustacheListAspect {
// === RagConnect ===
- syn boolean RagConnect.hasTreeListEndpoints() {
- for (EndpointDefinition endpointDef : allEndpointDefinitionList()) {
- if (endpointDef.typeIsList()) {
+ syn boolean RagConnect.hasTreeListPorts() {
+ for (PortDefinition portDef : allPortDefinitionList()) {
+ if (portDef.typeIsList()) {
return true;
}
}
return false;
}
- syn Set<TypeDecl> RagConnect.typesForReceivingListEndpoints() {
+ syn Set<TypeDecl> RagConnect.typesForReceivingListPorts() {
Set<TypeDecl> result = new HashSet<>();
- for (EndpointDefinition endpointDef : allEndpointDefinitionList()) {
- if (endpointDef.typeIsList() && !endpointDef.getSend()) {
- result.add(endpointDef.type().getTypeDecl());
+ for (PortDefinition portDef : allPortDefinitionList()) {
+ if (portDef.typeIsList() && !portDef.getSend()) {
+ result.add(portDef.type().getTypeDecl());
}
}
return result;
@@ -158,16 +158,16 @@ aspect MustacheListAspect {
}
aspect MustacheMappingApplicationAndDefinition {
- // === EndpointDefinition ===
- syn String EndpointDefinition.condition() {
+ // === PortDefinition ===
+ syn String PortDefinition.condition() {
// TODO [OLD] probably, this has to be structured in a better way
if (lastDefinition().getMappingDefinition().getToType().isArray()) {
return "java.util.Arrays.equals(" + preemptiveExpectedValue() + ", " + lastResult() + ")";
}
- if (getEndpointTarget().isTokenEndpointTarget() && token().isPrimitiveType() && lastDefinition().getMappingDefinition().getToType().isPrimitiveType()) {
+ if (getPortTarget().isTokenPortTarget() && token().isPrimitiveType() && lastDefinition().getMappingDefinition().getToType().isPrimitiveType()) {
return preemptiveExpectedValue() + " == " + lastResult();
}
- if (!getSend() && getEndpointTarget().isTypeEndpointTarget() && getWithAdd()) {
+ if (!getSend() && getPortTarget().isTypePortTarget() && getWithAdd()) {
// only check if received list is not null
return lastResult() + " == null";
}
@@ -176,7 +176,7 @@ aspect MustacheMappingApplicationAndDefinition {
// for wildcard (list) receive connect
toPrepend = "index >= 0 && ";
}
- if (getEndpointTarget().isTypeEndpointTarget() && type().isOptComponent()) {
+ if (getPortTarget().isTypePortTarget() && type().isOptComponent()) {
// use "hasX()" instead of "getX() != null" for optionals
return toPrepend + "has" + typeName() + "()" + " && " + preemptiveExpectedValue() + ".equals(" + lastResult() + ")";
}
@@ -186,22 +186,22 @@ aspect MustacheMappingApplicationAndDefinition {
return toPrepend + preemptiveExpectedValue() + " != null ? " + preemptiveExpectedValue() + ".equals(" + lastResult() + ") : " + lastResult() + " == null";
}
- syn JastAddList<MInnerMappingDefinition> EndpointDefinition.innerMappingDefinitions() = toMustache().getInnerMappingDefinitionList();
+ syn JastAddList<MInnerMappingDefinition> PortDefinition.innerMappingDefinitions() = toMustache().getInnerMappingDefinitionList();
- syn String EndpointDefinition.lastDefinitionToType() = lastDefinition().toType();
+ syn String PortDefinition.lastDefinitionToType() = lastDefinition().toType();
- syn String EndpointDefinition.preemptiveReturn() = toMustache().preemptiveReturn();
+ syn String PortDefinition.preemptiveReturn() = toMustache().preemptiveReturn();
// === (MInner)MappingDefinition ===
syn String MappingDefinition.fromType() = getFromType().prettyPrint();
inh boolean MInnerMappingDefinition.isLast();
- eq MEndpointDefinition.getInnerMappingDefinition(int i).isLast() {
+ eq MPortDefinition.getInnerMappingDefinition(int i).isLast() {
return i == getNumInnerMappingDefinition() - 1;
}
inh String MInnerMappingDefinition.inputVarName();
- eq MEndpointDefinition.getInnerMappingDefinition(int i).inputVarName() {
+ eq MPortDefinition.getInnerMappingDefinition(int i).inputVarName() {
return i == 0
? firstInputVarName()
: getInnerMappingDefinition(i - 1).outputVarName();
@@ -216,12 +216,12 @@ aspect MustacheMappingApplicationAndDefinition {
syn String MappingDefinition.toType() = getToType().prettyPrint();
// === attributes needed for computing above ones ===
- syn String EndpointDefinition.preemptiveExpectedValue() = toMustache().preemptiveExpectedValue();
- syn String EndpointDefinition.firstInputVarName() = toMustache().firstInputVarName();
+ syn String PortDefinition.preemptiveExpectedValue() = toMustache().preemptiveExpectedValue();
+ syn String PortDefinition.firstInputVarName() = toMustache().firstInputVarName();
- syn String MEndpointDefinition.preemptiveExpectedValue();
- syn String MEndpointDefinition.preemptiveReturn();
- syn String MEndpointDefinition.firstInputVarName();
+ syn String MPortDefinition.preemptiveExpectedValue();
+ syn String MPortDefinition.preemptiveReturn();
+ syn String MPortDefinition.firstInputVarName();
eq MAttributeSendDefinition.firstInputVarName() = getterMethodCall();
eq MAttributeSendDefinition.preemptiveExpectedValue() = lastValueGetterCall();
@@ -255,9 +255,9 @@ aspect MustacheMappingApplicationAndDefinition {
eq MContextFreeTypeSendDefinition.preemptiveExpectedValue() = null;
eq MContextFreeTypeSendDefinition.preemptiveReturn() = null;
- syn String MEndpointDefinition.parentTypeName() = getEndpointDefinition().parentTypeName();
+ syn String MPortDefinition.parentTypeName() = getPortDefinition().parentTypeName();
- syn String MEndpointDefinition.getterMethodCall() = getEndpointDefinition().getterMethodCall();
+ syn String MPortDefinition.getterMethodCall() = getPortDefinition().getterMethodCall();
}
aspect MustacheRagConnect {
@@ -270,17 +270,17 @@ aspect MustacheRagConnect {
return result;
}
- syn List<EndpointDefinition> RagConnect.allEndpointDefinitionList() {
- List<EndpointDefinition> result = new ArrayList<>();
- // first gather all user-defined endpoint definitions, that are not context-free
- for (EndpointDefinition def : givenEndpointDefinitionList()) {
- if (!def.hasContextFreeTypeEndpointTarget()) {
+ syn List<PortDefinition> RagConnect.allPortDefinitionList() {
+ List<PortDefinition> result = new ArrayList<>();
+ // first gather all user-defined port definitions, that are not context-free
+ for (PortDefinition def : givenPortDefinitionList()) {
+ if (!def.hasContextFreeTypePortTarget()) {
result.add(def);
}
}
- // then check for additional endpoints, and add if no conflict with existing definitions exists
- for (EndpointDefinition def : givenEndpointDefinitionList()) {
- def.getEndpointTarget().impliedEndpointDefinitions().iterator().forEachRemaining(result::add);
+ // then check for additional ports, and add if no conflict with existing definitions exists
+ for (PortDefinition def : givenPortDefinitionList()) {
+ def.getPortTarget().impliedPortDefinitions().iterator().forEachRemaining(result::add);
}
return result;
@@ -321,11 +321,11 @@ aspect MustacheRagConnect {
syn String RagConnect.touchedTerminalsMethodName() = internalRagConnectPrefix() + "touchedTerminals";
- syn List<TypeDecl> RagConnect.typeDeclsOfContextFreeEndpointTargets() {
+ syn List<TypeDecl> RagConnect.typeDeclsOfContextFreePortTargets() {
List<TypeDecl> result = new ArrayList<>();
- for (EndpointTarget target : givenEndpointTargetList()) {
- if (target.isContextFreeTypeEndpointTarget()) {
- result.add(target.asContextFreeTypeEndpointTarget().getTypeDecl());
+ for (PortTarget target : givenPortTargetList()) {
+ if (target.isContextFreeTypePortTarget()) {
+ result.add(target.asContextFreeTypePortTarget().getTypeDecl());
}
}
return result;
@@ -339,40 +339,40 @@ aspect MustacheRagConnect {
typeDecl -> ragconnect().defaultBytesToListMapping(typeDecl.getName()).isUsed());
// === attributes needed for computing above ones ===
- syn List<EndpointDefinition> RagConnect.givenEndpointDefinitionList() {
- List<EndpointDefinition> result = new ArrayList<>();
+ syn List<PortDefinition> RagConnect.givenPortDefinitionList() {
+ List<PortDefinition> result = new ArrayList<>();
for (ConnectSpecification spec : getConnectSpecificationFileList()) {
- spec.getEndpointDefinitionList().forEach(result::add);
+ spec.getPortDefinitionList().forEach(result::add);
}
return result;
}
- syn nta JastAddList<EndpointDefinition> EndpointTarget.impliedEndpointDefinitions() = new JastAddList<>();
-// eq TypeEndpointTarget.impliedEndpointDefinitions() {
-// JastAddList<EndpointDefinition> result = super.impliedEndpointDefinitions();
+ syn nta JastAddList<PortDefinition> PortTarget.impliedPortDefinitions() = new JastAddList<>();
+// eq TypePortTarget.impliedPortDefinitions() {
+// JastAddList<PortDefinition> result = super.impliedPortDefinitions();
// if (!getSend() || !typeIsList() || !getIndexBasedListAccess()) {
// return result;
// }
-// // create a new endpoint
+// // create a new port
// }
- eq ContextFreeTypeEndpointTarget.impliedEndpointDefinitions() {
- JastAddList<EndpointDefinition> result = super.impliedEndpointDefinitions();
- EndpointDefinition containingDef = containingEndpointDefinition();
+ eq ContextFreeTypePortTarget.impliedPortDefinitions() {
+ JastAddList<PortDefinition> result = super.impliedPortDefinitions();
+ PortDefinition containingDef = containingPortDefinition();
for (TypeComponent typeComponent : getTypeDecl().occurencesInProductionRules()) {
- List<EndpointDefinition> defsForTypeComponent = lookupGivenTypeEndpointDefinitions(typeComponent);
+ List<PortDefinition> defsForTypeComponent = lookupGivenTypePortDefinitions(typeComponent);
if (!defsForTypeComponent.stream().anyMatch(containingDef::matchesType)) {
- // there is no user-defined endpoint definition for this typeComponent yet
- // -> create a new endpoint definition with the same options and mappings as the context-free def
+ // there is no user-defined port definition for this typeComponent yet
+ // -> create a new port definition with the same options and mappings as the context-free def
// (except indexed-based for list-types)
- EndpointDefinition newDef = new EndpointDefinition();
+ PortDefinition newDef = new PortDefinition();
newDef.setAlwaysApply(containingDef.getAlwaysApply());
newDef.setIndexBasedListAccess(typeComponent.isListComponent());
newDef.setSend(containingDef.getSend());
containingDef.getMappings().forEach(newDef::addMapping);
- TypeEndpointTarget target = new TypeEndpointTarget();
+ TypePortTarget target = new TypePortTarget();
target.setType(typeComponent);
- newDef.setEndpointTarget(target);
+ newDef.setPortTarget(target);
result.add(newDef);
}
@@ -392,24 +392,24 @@ aspect MustacheRagConnect {
}
aspect MustacheReceiveAndSendAndHandleUri {
- // === EndpointDefinition ===
- syn String EndpointDefinition.connectMethodName() = "connect" + capitalize(entityName());
+ // === PortDefinition ===
+ syn String PortDefinition.connectMethodName() = "connect" + capitalize(entityName());
- syn String EndpointDefinition.connectParameterName() = "uriString";
+ syn String PortDefinition.connectParameterName() = "uriString";
- syn String EndpointDefinition.disconnectMethodName() {
- // if both (send and receive) are defined for an endpoint, ensure methods with different names
+ syn String PortDefinition.disconnectMethodName() {
+ // if both (send and receive) are defined for an port, ensure methods with different names
String extra;
- if (getEndpointTarget().isTokenEndpointTarget()) {
- extra = lookupTokenEndpointDefinitions(token()).size() > 1 ? uniqueSuffix() : "";
- } else if (getEndpointTarget().isTypeEndpointTarget()) {
- // here it has to be checked if there are ANY typeEndpointDefinitions within all endpoints (including implied)
- extra = lookupAllTypeEndpointDefinitions(type()).size() > 1 ? uniqueSuffix() : "";
- } else if (getEndpointTarget().isContextFreeTypeEndpointTarget()) {
- // here it has to be checked if there are ANY typeEndpointDefinitions within all endpoints (including implied)
+ if (getPortTarget().isTokenPortTarget()) {
+ extra = lookupTokenPortDefinitions(token()).size() > 1 ? uniqueSuffix() : "";
+ } else if (getPortTarget().isTypePortTarget()) {
+ // here it has to be checked if there are ANY typePortDefinitions within all ports (including implied)
+ extra = lookupAllTypePortDefinitions(type()).size() > 1 ? uniqueSuffix() : "";
+ } else if (getPortTarget().isContextFreeTypePortTarget()) {
+ // here it has to be checked if there are ANY typePortDefinitions within all ports (including implied)
boolean needExtra = false;
- for (TypeComponent typeComponent : getEndpointTarget().asContextFreeTypeEndpointTarget().getTypeDecl().occurencesInProductionRules()) {
- if (lookupAllTypeEndpointDefinitions(typeComponent).size() > 1) {
+ for (TypeComponent typeComponent : getPortTarget().asContextFreeTypePortTarget().getTypeDecl().occurencesInProductionRules()) {
+ if (lookupAllTypePortDefinitions(typeComponent).size() > 1) {
needExtra = true;
break;
}
@@ -421,106 +421,106 @@ aspect MustacheReceiveAndSendAndHandleUri {
return "disconnect" + extra + capitalize(entityName());
}
- syn String EndpointDefinition.entityName() = getEndpointTarget().entityName();
+ syn String PortDefinition.entityName() = getPortTarget().entityName();
- syn boolean EndpointDefinition.indexedSend() = getSend() && indexedList();
- syn boolean EndpointDefinition.indexedList() = typeIsList() && getIndexBasedListAccess();
+ syn boolean PortDefinition.indexedSend() = getSend() && indexedList();
+ syn boolean PortDefinition.indexedList() = typeIsList() && getIndexBasedListAccess();
- syn String EndpointDefinition.getterMethodName() = getEndpointTarget().getterMethodName();
- syn String EndpointDefinition.getterMethodCall() = getEndpointTarget().getterMethodCall();
- syn String EndpointDefinition.realGetterMethodName() = getEndpointTarget().realGetterMethodName();
- syn String EndpointDefinition.realGetterMethodCall() = getEndpointTarget().realGetterMethodCall();
+ syn String PortDefinition.getterMethodName() = getPortTarget().getterMethodName();
+ syn String PortDefinition.getterMethodCall() = getPortTarget().getterMethodCall();
+ syn String PortDefinition.realGetterMethodName() = getPortTarget().realGetterMethodName();
+ syn String PortDefinition.realGetterMethodCall() = getPortTarget().realGetterMethodCall();
- syn String EndpointDefinition.parentTypeName() = getEndpointTarget().parentTypeName();
+ syn String PortDefinition.parentTypeName() = getPortTarget().parentTypeName();
// === attributes needed for computing above ones ===
- syn String EndpointTarget.getterMethodName();
- syn String EndpointTarget.getterMethodCall() = getterMethodName() + "()";
- syn String EndpointTarget.realGetterMethodName() = getterMethodName() + "NoTransform";
- syn String EndpointTarget.realGetterMethodCall() = realGetterMethodName() + "()";
- syn String EndpointTarget.parentTypeName();
- syn String EndpointTarget.entityName();
-
- eq AttributeEndpointTarget.getterMethodName() = getName();
- eq AttributeEndpointTarget.parentTypeName() = getParentTypeDecl().getName();
- eq AttributeEndpointTarget.entityName() = getName();
-
- eq RelationEndpointTarget.getterMethodName() = forwardingName();
- eq RelationEndpointTarget.parentTypeName() = getRole().getType().getName();
- eq RelationEndpointTarget.entityName() = getRole().getName();
- eq RelationEndpointTarget.realGetterMethodName() = "get" + getRole().getterMethodName();
- eq RelationEndpointTarget.realGetterMethodCall() = realGetterMethodName() + (containingEndpointDefinition().indexedSend() ? "(index)" : "()");
+ syn String PortTarget.getterMethodName();
+ syn String PortTarget.getterMethodCall() = getterMethodName() + "()";
+ syn String PortTarget.realGetterMethodName() = getterMethodName() + "NoTransform";
+ syn String PortTarget.realGetterMethodCall() = realGetterMethodName() + "()";
+ syn String PortTarget.parentTypeName();
+ syn String PortTarget.entityName();
+
+ eq AttributePortTarget.getterMethodName() = getName();
+ eq AttributePortTarget.parentTypeName() = getParentTypeDecl().getName();
+ eq AttributePortTarget.entityName() = getName();
+
+ eq RelationPortTarget.getterMethodName() = forwardingName();
+ eq RelationPortTarget.parentTypeName() = getRole().getType().getName();
+ eq RelationPortTarget.entityName() = getRole().getName();
+ eq RelationPortTarget.realGetterMethodName() = "get" + getRole().getterMethodName();
+ eq RelationPortTarget.realGetterMethodCall() = realGetterMethodName() + (containingPortDefinition().indexedSend() ? "(index)" : "()");
syn String NavigableRole.getterMethodName() = getName();
eq ListRole.getterMethodName() = getName() + "List";
- eq TokenEndpointTarget.getterMethodName() = "get" + getToken().getName();
- eq TokenEndpointTarget.parentTypeName() = getToken().containingTypeDecl().getName();
- eq TokenEndpointTarget.entityName() = getToken().getName();
+ eq TokenPortTarget.getterMethodName() = "get" + getToken().getName();
+ eq TokenPortTarget.parentTypeName() = getToken().containingTypeDecl().getName();
+ eq TokenPortTarget.entityName() = getToken().getName();
- eq TypeEndpointTarget.getterMethodName() = getterMethodeNameHelper(true);
- eq TypeEndpointTarget.getterMethodCall() = getterMethodName() + (containingEndpointDefinition().indexedList() && !containingEndpointDefinition().getWithAdd() ? "(index)" : "()") + (typeIsOpt() ? ".getChild(0)" : "");
- eq TypeEndpointTarget.realGetterMethodName() = getterMethodeNameHelper(false);
- eq TypeEndpointTarget.realGetterMethodCall() = realGetterMethodName() + (containingEndpointDefinition().indexedSend() ? "(index)" : "()");
- eq TypeEndpointTarget.parentTypeName() = getType().containingTypeDecl().getName();
- eq TypeEndpointTarget.entityName() = getType().getName() + (typeIsList() && !containingEndpointDefinition().getIndexBasedListAccess() ? "List" : "");
+ eq TypePortTarget.getterMethodName() = getterMethodeNameHelper(true);
+ eq TypePortTarget.getterMethodCall() = getterMethodName() + (containingPortDefinition().indexedList() && !containingPortDefinition().getWithAdd() ? "(index)" : "()") + (typeIsOpt() ? ".getChild(0)" : "");
+ eq TypePortTarget.realGetterMethodName() = getterMethodeNameHelper(false);
+ eq TypePortTarget.realGetterMethodCall() = realGetterMethodName() + (containingPortDefinition().indexedSend() ? "(index)" : "()");
+ eq TypePortTarget.parentTypeName() = getType().containingTypeDecl().getName();
+ eq TypePortTarget.entityName() = getType().getName() + (typeIsList() && !containingPortDefinition().getIndexBasedListAccess() ? "List" : "");
- private String TypeEndpointTarget.getterMethodeNameHelper(boolean useForwarding) {
+ private String TypePortTarget.getterMethodeNameHelper(boolean useForwarding) {
return (useForwarding && needForwarding() ? forwardingName() :
- "get" + getType().getName() + (typeIsList() && (!containingEndpointDefinition().getIndexBasedListAccess() ||
- containingEndpointDefinition().getWithAdd()) ? "List" : "") + (typeIsOpt() ? "Opt" : "")
+ "get" + getType().getName() + (typeIsList() && (!containingPortDefinition().getIndexBasedListAccess() ||
+ containingPortDefinition().getWithAdd()) ? "List" : "") + (typeIsOpt() ? "Opt" : "")
+ (needForwarding() ? "NoTransform" : ""));
}
- eq ContextFreeTypeEndpointTarget.getterMethodName() = null;
- eq ContextFreeTypeEndpointTarget.parentTypeName() = getTypeDecl().getName();
- eq ContextFreeTypeEndpointTarget.entityName() = "";
+ eq ContextFreeTypePortTarget.getterMethodName() = null;
+ eq ContextFreeTypePortTarget.parentTypeName() = getTypeDecl().getName();
+ eq ContextFreeTypePortTarget.entityName() = "";
}
aspect MustacheReceiveDefinition {
// === RagConnect ===
syn boolean RagConnect.configLoggingEnabledForReads() = getConfiguration().getLoggingEnabledForReads();
- // === EndpointDefinition ===
- syn boolean EndpointDefinition.hasContextFreeTypeEndpointTarget() = getEndpointTarget().isContextFreeTypeEndpointTarget();
+ // === PortDefinition ===
+ syn boolean PortDefinition.hasContextFreeTypePortTarget() = getPortTarget().isContextFreeTypePortTarget();
- syn boolean EndpointDefinition.hasTypeEndpointTarget() = getEndpointTarget().isTypeEndpointTarget();
+ syn boolean PortDefinition.hasTypePortTarget() = getPortTarget().isTypePortTarget();
- syn String EndpointDefinition.idTokenName() = ragconnect().internalRagConnectPrefix() + "TopicInList";
+ syn String PortDefinition.idTokenName() = ragconnect().internalRagConnectPrefix() + "TopicInList";
- syn String EndpointDefinition.internalConnectMethodName() = ragconnect().internalRagConnectPrefix() + "_internal_" + connectMethodName();
+ syn String PortDefinition.internalConnectMethodName() = ragconnect().internalRagConnectPrefix() + "_internal_" + connectMethodName();
- syn String EndpointDefinition.resolveInListMethodName() = ragconnect().internalRagConnectPrefix() + "_resolve" + entityName() + "InList";
+ syn String PortDefinition.resolveInListMethodName() = ragconnect().internalRagConnectPrefix() + "_resolve" + entityName() + "InList";
// === attributes needed for computing above ones ===
- syn String EndpointDefinition.uniqueSuffix() = getSend() ? "Send" : "Receive";
+ syn String PortDefinition.uniqueSuffix() = getSend() ? "Send" : "Receive";
}
aspect MustacheSendDefinition {
// === RagConnect ===
syn boolean RagConnect.configLoggingEnabledForWrites() = getConfiguration().getLoggingEnabledForWrites();
- // === EndpointDefinition ===
- syn String EndpointDefinition.lastValueGetterCall() = senderName() + ".getLastValue(" +
+ // === PortDefinition ===
+ syn String PortDefinition.lastValueGetterCall() = senderName() + ".getLastValue(" +
(getIndexBasedListAccess() ? "index" : "") + ")";
- syn String EndpointDefinition.lastValueSetter() = senderName() + ".setLastValue";
+ syn String PortDefinition.lastValueSetter() = senderName() + ".setLastValue";
- syn boolean EndpointDefinition.needForwarding() = getEndpointTarget().needForwarding();
- syn String EndpointDefinition.forwardingName() = getEndpointTarget().forwardingName();
- syn String EndpointDefinition.forwardingType() = getEndpointTarget().forwardingType();
+ syn boolean PortDefinition.needForwarding() = getPortTarget().needForwarding();
+ syn String PortDefinition.forwardingName() = getPortTarget().forwardingName();
+ syn String PortDefinition.forwardingType() = getPortTarget().forwardingType();
- syn boolean EndpointDefinition.targetIsAttribute() = getEndpointTarget().isAttributeEndpointTarget();
+ syn boolean PortDefinition.targetIsAttribute() = getPortTarget().isAttributePortTarget();
- syn boolean EndpointDefinition.indexBasedAccessAndTargetIsNTA() {
+ syn boolean PortDefinition.indexBasedAccessAndTargetIsNTA() {
return typeIsList() && getIndexBasedListAccess() && !needForwarding();
}
- syn boolean EndpointDefinition.relationEndpointWithListRole() = getEndpointTarget().relationEndpointWithListRole();
+ syn boolean PortDefinition.relationPortWithListRole() = getPortTarget().relationPortWithListRole();
- syn String EndpointDefinition.senderName() = getEndpointTarget().senderName();
+ syn String PortDefinition.senderName() = getPortTarget().senderName();
- syn java.util.List<SendIncrementalObserverEntry> EndpointDefinition.sendIncrementalObserverEntries() {
+ syn java.util.List<SendIncrementalObserverEntry> PortDefinition.sendIncrementalObserverEntries() {
// todo maybe getterMethodName needs to be change for indexed send
java.util.List<SendIncrementalObserverEntry> result = new java.util.ArrayList<>();
// "{{getterMethodName}}{{#IndexBasedListAccess}}_int{{/IndexBasedListAccess}}"
@@ -537,28 +537,28 @@ aspect MustacheSendDefinition {
return result;
}
- syn boolean EndpointDefinition.shouldNotResetValue() = getSend() && !getEndpointTarget().hasAttributeResetMethod();
+ syn boolean PortDefinition.shouldNotResetValue() = getSend() && !getPortTarget().hasAttributeResetMethod();
- syn String EndpointDefinition.tokenResetMethodName() = getEndpointTarget().tokenResetMethodName();
+ syn String PortDefinition.tokenResetMethodName() = getPortTarget().tokenResetMethodName();
- syn String EndpointDefinition.updateMethodName() = toMustache().updateMethodName();
+ syn String PortDefinition.updateMethodName() = toMustache().updateMethodName();
- syn String EndpointDefinition.writeMethodName() = toMustache().writeMethodName();
+ syn String PortDefinition.writeMethodName() = toMustache().writeMethodName();
// === attributes needed for computing above ones ===
- syn boolean EndpointTarget.needForwarding() = false;
- eq TypeEndpointTarget.needForwarding() = containingEndpointDefinition().getSend() && !getType().getNTA();
- eq RelationEndpointTarget.needForwarding() = containingEndpointDefinition().getSend();
+ syn boolean PortTarget.needForwarding() = false;
+ eq TypePortTarget.needForwarding() = containingPortDefinition().getSend() && !getType().getNTA();
+ eq RelationPortTarget.needForwarding() = containingPortDefinition().getSend();
- syn String EndpointTarget.forwardingName() = null; // only needed, if needForwarding evaluates to true
- eq TypeEndpointTarget.forwardingName() = ragconnect().internalRagConnectPrefix() + getType().getName();
- eq RelationEndpointTarget.forwardingName() = ragconnect().internalRagConnectPrefix() + getRole().getName();
+ syn String PortTarget.forwardingName() = null; // only needed, if needForwarding evaluates to true
+ eq TypePortTarget.forwardingName() = ragconnect().internalRagConnectPrefix() + getType().getName();
+ eq RelationPortTarget.forwardingName() = ragconnect().internalRagConnectPrefix() + getRole().getName();
- syn String EndpointTarget.forwardingType() = null; // only needed, if needForwarding evaluates to true
- eq TypeEndpointTarget.forwardingType() = getType().forwardingType(
- containingEndpointDefinition().getIndexBasedListAccess());
- eq RelationEndpointTarget.forwardingType() = getRole().forwardingType(
-containingEndpointDefinition().getIndexBasedListAccess());
+ syn String PortTarget.forwardingType() = null; // only needed, if needForwarding evaluates to true
+ eq TypePortTarget.forwardingType() = getType().forwardingType(
+ containingPortDefinition().getIndexBasedListAccess());
+ eq RelationPortTarget.forwardingType() = getRole().forwardingType(
+containingPortDefinition().getIndexBasedListAccess());
syn String TypeComponent.forwardingType(boolean indexBasedListAccess);
eq NormalComponent.forwardingType(boolean indexBasedListAccess) = getTypeDecl().getName();
@@ -573,23 +573,23 @@ containingEndpointDefinition().getIndexBasedListAccess());
oppositeRole().getType().getName() :
"java.util.List<" + oppositeRole().getType().getName() + ">";
- syn boolean EndpointTarget.relationEndpointWithListRole() = false;
- eq RelationEndpointTarget.relationEndpointWithListRole() = getRole().isListRole();
+ syn boolean PortTarget.relationPortWithListRole() = false;
+ eq RelationPortTarget.relationPortWithListRole() = getRole().isListRole();
- syn String EndpointTarget.senderName() = ragconnect().internalRagConnectPrefix() + "_sender_" + entityName();
- eq ContextFreeTypeEndpointTarget.senderName() = null;
+ syn String PortTarget.senderName() = ragconnect().internalRagConnectPrefix() + "_sender_" + entityName();
+ eq ContextFreeTypePortTarget.senderName() = null;
- syn String EndpointTarget.tokenResetMethodName() = getterMethodName() + (
- typeIsList() && containingEndpointDefinition().getIndexBasedListAccess() ? "List" : "") + "_reset";
+ syn String PortTarget.tokenResetMethodName() = getterMethodName() + (
+ typeIsList() && containingPortDefinition().getIndexBasedListAccess() ? "List" : "") + "_reset";
- syn String MEndpointDefinition.updateMethodName();
- syn String MEndpointDefinition.writeMethodName();
+ syn String MPortDefinition.updateMethodName();
+ syn String MPortDefinition.writeMethodName();
- eq MAttributeSendDefinition.updateMethodName() = ragconnect().internalRagConnectPrefix() + "_update_attr_" + getEndpointDefinition().entityName();
- eq MAttributeSendDefinition.writeMethodName() = ragconnect().internalRagConnectPrefix() + "_writeLastValue_attr_" + getEndpointDefinition().entityName();
+ eq MAttributeSendDefinition.updateMethodName() = ragconnect().internalRagConnectPrefix() + "_update_attr_" + getPortDefinition().entityName();
+ eq MAttributeSendDefinition.writeMethodName() = ragconnect().internalRagConnectPrefix() + "_writeLastValue_attr_" + getPortDefinition().entityName();
- eq MRelationSendDefinition.updateMethodName() = ragconnect().internalRagConnectPrefix() + "_update_" + getEndpointDefinition().entityName();
- eq MRelationSendDefinition.writeMethodName() = ragconnect().internalRagConnectPrefix() + "_writeLastValue_" + getEndpointDefinition().entityName();
+ eq MRelationSendDefinition.updateMethodName() = ragconnect().internalRagConnectPrefix() + "_update_" + getPortDefinition().entityName();
+ eq MRelationSendDefinition.writeMethodName() = ragconnect().internalRagConnectPrefix() + "_writeLastValue_" + getPortDefinition().entityName();
eq MTokenReceiveDefinition.updateMethodName() = null;
eq MTokenReceiveDefinition.writeMethodName() = null;
@@ -609,11 +609,11 @@ containingEndpointDefinition().getIndexBasedListAccess());
eq MContextFreeTypeSendDefinition.updateMethodName() = null;
eq MContextFreeTypeSendDefinition.writeMethodName() = null;
- syn String EndpointDefinition.tokenName() = token().getName();
- syn String MEndpointDefinition.tokenName() = getEndpointDefinition().tokenName();
+ syn String PortDefinition.tokenName() = token().getName();
+ syn String MPortDefinition.tokenName() = getPortDefinition().tokenName();
- syn String EndpointDefinition.typeName() = type().getName();
- syn String MEndpointDefinition.typeName() = getEndpointDefinition().typeName();
+ syn String PortDefinition.typeName() = type().getName();
+ syn String MPortDefinition.typeName() = getPortDefinition().typeName();
static SendIncrementalObserverEntry SendIncrementalObserverEntry.of(String attributeString, boolean compareParams, Object params) {
return new SendIncrementalObserverEntry()
@@ -629,10 +629,10 @@ aspect MustacheTokenComponent {
syn String TokenComponent.javaType() = effectiveJavaTypeUse().prettyPrint();
- syn EndpointDefinition TokenComponent.normalTokenSendDef() {
- for (EndpointTarget target : getTokenEndpointTargetList()) {
- if (target.isTokenEndpointTarget() && target.containingEndpointDefinition().shouldNotResetValue()) {
- return target.containingEndpointDefinition();
+ syn PortDefinition TokenComponent.normalTokenSendDef() {
+ for (PortTarget target : getTokenPortTargetList()) {
+ if (target.isTokenPortTarget() && target.containingPortDefinition().shouldNotResetValue()) {
+ return target.containingPortDefinition();
}
}
return null;
@@ -643,20 +643,20 @@ aspect MustacheTokenComponent {
// > see MustacheDependencyDefinition for internalRelationPrefix, targetParentTypeName
// === DependencyDefinition ===
- syn EndpointDefinition DependencyDefinition.targetEndpointDefinition() {
+ syn PortDefinition DependencyDefinition.targetPortDefinition() {
// resolve definition in here, as we do not need resolveMethod in any other place (yet)
- for (EndpointDefinition endpointDefinition : ragconnect().allEndpointDefinitionList()) {
- if (!endpointDefinition.getSend()) {
+ for (PortDefinition portDefinition : ragconnect().allPortDefinitionList()) {
+ if (!portDefinition.getSend()) {
continue;
}
- EndpointTarget endpointTarget = endpointDefinition.getEndpointTarget();
- if (endpointTarget.isTokenEndpointTarget() &&
- endpointTarget.asTokenEndpointTarget().getToken().equals(this.getTarget())) {
- return endpointDefinition;
+ PortTarget portTarget = portDefinition.getPortTarget();
+ if (portTarget.isTokenPortTarget() &&
+ portTarget.asTokenPortTarget().getToken().equals(this.getTarget())) {
+ return portDefinition;
}
- if (endpointTarget.isTypeEndpointTarget() &&
- endpointTarget.asTypeEndpointTarget().getType().equals(this.getTarget())) {
- return endpointDefinition;
+ if (portTarget.isTypePortTarget() &&
+ portTarget.asTypePortTarget().getType().equals(this.getTarget())) {
+ return portDefinition;
}
}
return null;
@@ -669,11 +669,11 @@ aspect MustacheTypeDecl {
// === TypeComponent ===
syn String TypeComponent.parentTypeName() = containingTypeDecl().getName();
syn String TypeComponent.disconnectMethodName() {
- List<TypeEndpointTarget> typeEndpointTargets = getTypeEndpointTargets();
- if (typeEndpointTargets.isEmpty()) {
- return "MISSING_ENDPOINT";
+ List<TypePortTarget> typePortTargets = getTypePortTargets();
+ if (typePortTargets.isEmpty()) {
+ return "MISSING_PORT";
} else {
- return typeEndpointTargets.get(0).containingEndpointDefinition().disconnectMethodName();
+ return typePortTargets.get(0).containingPortDefinition().disconnectMethodName();
}
}
@@ -693,19 +693,19 @@ aspect MustacheTypeDecl {
}
aspect AttributesForMustache {
- syn String MEndpointDefinition.lastValueGetterCall() = getEndpointDefinition().lastValueGetterCall();
- syn String MEndpointDefinition.lastValueSetter() = getEndpointDefinition().lastValueSetter();
+ syn String MPortDefinition.lastValueGetterCall() = getPortDefinition().lastValueGetterCall();
+ syn String MPortDefinition.lastValueSetter() = getPortDefinition().lastValueSetter();
- // token and type are potentially dangerous because asXEndpointTarget can return null
- syn TokenComponent EndpointDefinition.token() = getEndpointTarget().asTokenEndpointTarget().getToken();
- syn TypeComponent EndpointDefinition.type() = getEndpointTarget().asTypeEndpointTarget().getType();
+ // token and type are potentially dangerous because asXPortTarget can return null
+ syn TokenComponent PortDefinition.token() = getPortTarget().asTokenPortTarget().getToken();
+ syn TypeComponent PortDefinition.type() = getPortTarget().asTypePortTarget().getType();
- syn MInnerMappingDefinition EndpointDefinition.lastDefinition() = toMustache().lastDefinition();
- syn MInnerMappingDefinition MEndpointDefinition.lastDefinition() = getInnerMappingDefinition(getNumInnerMappingDefinition() - 1);
+ syn MInnerMappingDefinition PortDefinition.lastDefinition() = toMustache().lastDefinition();
+ syn MInnerMappingDefinition MPortDefinition.lastDefinition() = getInnerMappingDefinition(getNumInnerMappingDefinition() - 1);
- syn nta MEndpointDefinition EndpointDefinition.toMustache() {
- final MEndpointDefinition result = getEndpointTarget().createMEndpointDefinition(getSend());
- result.setEndpointDefinition(this);
+ syn nta MPortDefinition PortDefinition.toMustache() {
+ final MPortDefinition result = getPortTarget().createMPortDefinition(getSend());
+ result.setPortDefinition(this);
for (MappingDefinition def : effectiveMappings()) {
MInnerMappingDefinition inner = new MInnerMappingDefinition();
inner.setMappingDefinition(def);
@@ -713,30 +713,30 @@ aspect AttributesForMustache {
}
return result;
}
- abstract MEndpointDefinition EndpointTarget.createMEndpointDefinition(boolean isSend);
- MEndpointDefinition AttributeEndpointTarget.createMEndpointDefinition(boolean isSend) {
+ abstract MPortDefinition PortTarget.createMPortDefinition(boolean isSend);
+ MPortDefinition AttributePortTarget.createMPortDefinition(boolean isSend) {
if (!isSend) {
- throw new IllegalArgumentException("AttributeEndpointTarget can only be sent!");
+ throw new IllegalArgumentException("AttributePortTarget can only be sent!");
}
return new MAttributeSendDefinition();
}
- MEndpointDefinition RelationEndpointTarget.createMEndpointDefinition(boolean isSend) {
+ MPortDefinition RelationPortTarget.createMPortDefinition(boolean isSend) {
if (!isSend) {
- throw new IllegalArgumentException("RelationEndpointTarget can only be sent!");
+ throw new IllegalArgumentException("RelationPortTarget can only be sent!");
}
return new MRelationSendDefinition();
}
- MEndpointDefinition TokenEndpointTarget.createMEndpointDefinition(boolean isSend) {
+ MPortDefinition TokenPortTarget.createMPortDefinition(boolean isSend) {
return isSend ? new MTokenSendDefinition() : new MTokenReceiveDefinition();
}
- MEndpointDefinition TypeEndpointTarget.createMEndpointDefinition(boolean isSend) {
+ MPortDefinition TypePortTarget.createMPortDefinition(boolean isSend) {
return isSend ? new MTypeSendDefinition() : new MTypeReceiveDefinition();
}
- MEndpointDefinition ContextFreeTypeEndpointTarget.createMEndpointDefinition(boolean isSend) {
+ MPortDefinition ContextFreeTypePortTarget.createMPortDefinition(boolean isSend) {
return isSend ? new MContextFreeTypeSendDefinition() : new MContextFreeTypeReceiveDefinition();
}
- MEndpointDefinition UntypedEndpointTarget.createMEndpointDefinition(boolean isSend) {
- throw new RuntimeException("Could not resolve endpoint target '" +
+ MPortDefinition UntypedPortTarget.createMPortDefinition(boolean isSend) {
+ throw new RuntimeException("Could not resolve port target '" +
getTypeName() + "." + getChildName() + "'");
}
}
@@ -764,7 +764,7 @@ aspect GrammarGeneration {
syn java.util.Map<TypeDecl, TokenComponent> RagConnect.additionalTokens() {
java.util.Map<TypeDecl, TokenComponent> result = new java.util.HashMap<>();
- for (EndpointDefinition def : allEndpointDefinitionList()) {
+ for (PortDefinition def : allPortDefinitionList()) {
if (def.getTokenToCreate() != null) {
result.put(def.type().getTypeDecl(), def.getTokenToCreate());
}
@@ -772,7 +772,7 @@ aspect GrammarGeneration {
return result;
}
- syn TokenComponent EndpointDefinition.getTokenToCreate() {
+ syn TokenComponent PortDefinition.getTokenToCreate() {
if (typeIsList() && getIndexBasedListAccess()) {
TokenComponent result = new TokenComponent();
result.setName(idTokenName());
diff --git a/ragconnect.base/src/main/jastadd/Intermediate.relast b/ragconnect.base/src/main/jastadd/Intermediate.relast
index 0307d8d9a45fc40e2d6fcfa03ab06d25578687d6..3e29f479565db55e894dfbcc60a23cd7a972355b 100644
--- a/ragconnect.base/src/main/jastadd/Intermediate.relast
+++ b/ragconnect.base/src/main/jastadd/Intermediate.relast
@@ -1,17 +1,17 @@
-abstract MEndpointDefinition ::= InnerMappingDefinition:MInnerMappingDefinition*;
-rel MEndpointDefinition.EndpointDefinition -> EndpointDefinition;
+abstract MPortDefinition ::= InnerMappingDefinition:MInnerMappingDefinition*;
+rel MPortDefinition.PortDefinition -> PortDefinition;
-MAttributeSendDefinition : MEndpointDefinition;
-MRelationSendDefinition : MEndpointDefinition;
-abstract MTokenEndpointDefinition : MEndpointDefinition;
-MTokenReceiveDefinition : MTokenEndpointDefinition;
-MTokenSendDefinition : MTokenEndpointDefinition;
-abstract MTypeEndpointDefinition : MEndpointDefinition;
-MTypeReceiveDefinition : MTypeEndpointDefinition;
-MTypeSendDefinition : MTypeEndpointDefinition;
-abstract MContextFreeTypeEndpointDefinition : MEndpointDefinition;
-MContextFreeTypeReceiveDefinition : MContextFreeTypeEndpointDefinition;
-MContextFreeTypeSendDefinition : MContextFreeTypeEndpointDefinition;
+MAttributeSendDefinition : MPortDefinition;
+MRelationSendDefinition : MPortDefinition;
+abstract MTokenPortDefinition : MPortDefinition;
+MTokenReceiveDefinition : MTokenPortDefinition;
+MTokenSendDefinition : MTokenPortDefinition;
+abstract MTypePortDefinition : MPortDefinition;
+MTypeReceiveDefinition : MTypePortDefinition;
+MTypeSendDefinition : MTypePortDefinition;
+abstract MContextFreeTypePortDefinition : MPortDefinition;
+MContextFreeTypeReceiveDefinition : MContextFreeTypePortDefinition;
+MContextFreeTypeSendDefinition : MContextFreeTypePortDefinition;
MInnerMappingDefinition;
rel MInnerMappingDefinition.MappingDefinition -> MappingDefinition;
diff --git a/ragconnect.base/src/main/jastadd/IntermediateToYAML.jrag b/ragconnect.base/src/main/jastadd/IntermediateToYAML.jrag
index 23f32d98edeca8b6befa698e885d75d986a30860..c247d9d0a69b2f548e04fe69adcf35620fd69255 100644
--- a/ragconnect.base/src/main/jastadd/IntermediateToYAML.jrag
+++ b/ragconnect.base/src/main/jastadd/IntermediateToYAML.jrag
@@ -27,12 +27,12 @@ aspect IntermediateToYAML {
// listAspect
root.put("configJastAddList" , configJastAddList());
- root.put("hasTreeListEndpoints" , hasTreeListEndpoints());
- ListElement typesForReceivingListEndpointsElement = new ListElement();
- for (TypeDecl typeDecl : typesForReceivingListEndpoints()) {
- typesForReceivingListEndpointsElement.addElement(typeDecl.toYAML());
+ root.put("hasTreeListPorts" , hasTreeListPorts());
+ ListElement typesForReceivingListPortsElement = new ListElement();
+ for (TypeDecl typeDecl : typesForReceivingListPorts()) {
+ typesForReceivingListPortsElement.addElement(typeDecl.toYAML());
}
- root.put("typesForReceivingListEndpoints" , typesForReceivingListEndpointsElement);
+ root.put("typesForReceivingListPorts" , typesForReceivingListPortsElement);
// ragconnect
ListElement dependencyDefinitionsElement = new ListElement();
@@ -40,11 +40,11 @@ aspect IntermediateToYAML {
dependencyDefinitionsElement.addElement(def.toYAML());
}
root.put("allDependencyDefinitionList" , dependencyDefinitionsElement);
- ListElement endpointDefinitionsElement = new ListElement();
- for (EndpointDefinition def : allEndpointDefinitionList()) {
- endpointDefinitionsElement.addElement(def.toYAML());
+ ListElement portDefinitionsElement = new ListElement();
+ for (PortDefinition def : allPortDefinitionList()) {
+ portDefinitionsElement.addElement(def.toYAML());
}
- root.put("allEndpointDefinitionList" , endpointDefinitionsElement);
+ root.put("allPortDefinitionList" , portDefinitionsElement);
ListElement mappingDefinitionsElement = new ListElement();
for (MappingDefinition def : allMappingDefinitions()) {
mappingDefinitionsElement.addElement(def.toYAML());
@@ -70,7 +70,7 @@ aspect IntermediateToYAML {
return doc;
}
- syn MappingElement EndpointDefinition.toYAML() {
+ syn MappingElement PortDefinition.toYAML() {
MappingElement result = new MappingElement();
// grammar children
result.put("AlwaysApply" , getAlwaysApply());
@@ -108,16 +108,16 @@ aspect IntermediateToYAML {
result.put("updateMethodName" , updateMethodName());
result.put("writeMethodName" , writeMethodName());
} else {
- result.put("hasTypeEndpointTarget" , hasTypeEndpointTarget());
+ result.put("hasTypePortTarget" , hasTypePortTarget());
result.put("idTokenName" , idTokenName());
result.put("internalConnectMethodName" , internalConnectMethodName());
result.put("resolveInListMethodName" , resolveInListMethodName());
- result.put("typeIsList" , getEndpointTarget().typeIsList());
+ result.put("typeIsList" , getPortTarget().typeIsList());
}
return result;
}
- void UntypedEndpointTarget.addToYAML(MappingElement result) {
+ void UntypedPortTarget.addToYAML(MappingElement result) {
// empty
}
@@ -167,7 +167,7 @@ aspect IntermediateToYAML {
result.put("targetParentTypeName" , targetParentTypeName());
// tokenComponent
- result.put("targetEndpointDefinition" , targetEndpointDefinition().toYAML());
+ result.put("targetPortDefinition" , targetPortDefinition().toYAML());
return result;
}
diff --git a/ragconnect.base/src/main/jastadd/Mappings.jrag b/ragconnect.base/src/main/jastadd/Mappings.jrag
index 133fae2fe3faea33de05727c72bbab6e7046efa0..c23df22f9469cd9e1ff7282541eb3321bd3108de 100644
--- a/ragconnect.base/src/main/jastadd/Mappings.jrag
+++ b/ragconnect.base/src/main/jastadd/Mappings.jrag
@@ -176,7 +176,7 @@ aspect TemplateDefaultMappingDefinitions {
aspect Mappings {
// --- effectiveMappings ---
- syn java.util.List<MappingDefinition> EndpointDefinition.effectiveMappings() {
+ syn java.util.List<MappingDefinition> PortDefinition.effectiveMappings() {
java.util.List<MappingDefinition> result;
if (!getSend()) {
// if no mappings are specified, or if first mapping is not suitable.
@@ -202,10 +202,10 @@ aspect Mappings {
}
// --- isPrimitiveType ---
- syn boolean EndpointDefinition.isPrimitiveType() = getEndpointTarget().isPrimitiveType();
- syn boolean EndpointTarget.isPrimitiveType() = false;
- eq TokenEndpointTarget.isPrimitiveType() = getToken().isPrimitiveType();
- eq AttributeEndpointTarget.isPrimitiveType() = new SimpleJavaTypeUse(getTypeName()).isPrimitiveType();
+ syn boolean PortDefinition.isPrimitiveType() = getPortTarget().isPrimitiveType();
+ syn boolean PortTarget.isPrimitiveType() = false;
+ eq TokenPortTarget.isPrimitiveType() = getToken().isPrimitiveType();
+ eq AttributePortTarget.isPrimitiveType() = new SimpleJavaTypeUse(getTypeName()).isPrimitiveType();
syn boolean TokenComponent.isPrimitiveType() = effectiveJavaTypeUse().isPrimitiveType();
syn boolean JavaTypeUse.isPrimitiveType() = false;
eq SimpleJavaTypeUse.isPrimitiveType() {
@@ -231,7 +231,7 @@ aspect Mappings {
eq JavaArrayMappingDefinitionType.isArray() = true;
// --- suitableReceiveDefaultMapping ---
- syn DefaultMappingDefinition EndpointDefinition.suitableReceiveDefaultMapping() {
+ syn DefaultMappingDefinition PortDefinition.suitableReceiveDefaultMapping() {
switch (targetTypeName()) {
case "boolean":
case "Boolean":
@@ -259,7 +259,7 @@ aspect Mappings {
default:
try {
TypeDecl typeDecl = program().resolveTypeDecl(targetTypeName());
- return getEndpointTarget().isTypeEndpointTarget() && typeIsList() && !getIndexBasedListAccess() ? ragconnect().defaultBytesToListMapping(typeDecl.getName()) : ragconnect().defaultBytesToTreeMapping(typeDecl.getName());
+ return getPortTarget().isTypePortTarget() && typeIsList() && !getIndexBasedListAccess() ? ragconnect().defaultBytesToListMapping(typeDecl.getName()) : ragconnect().defaultBytesToTreeMapping(typeDecl.getName());
} catch (Exception ignore) {
}
System.err.println("Could not find suitable default receive mapping for " + targetTypeName() + " on " + this);
@@ -268,7 +268,7 @@ aspect Mappings {
}
// --- suitableSendDefaultMapping ---
- syn DefaultMappingDefinition EndpointDefinition.suitableSendDefaultMapping() {
+ syn DefaultMappingDefinition PortDefinition.suitableSendDefaultMapping() {
switch (targetTypeName()) {
case "boolean":
case "Boolean":
@@ -294,10 +294,10 @@ aspect Mappings {
case "String":
return ragconnect().defaultStringToBytesMapping();
default:
- if (getEndpointTarget().isTypeEndpointTarget() && typeIsList() && !getIndexBasedListAccess()) {
+ if (getPortTarget().isTypePortTarget() && typeIsList() && !getIndexBasedListAccess()) {
return ragconnect().defaultListToBytesMapping();
}
- if (getEndpointTarget().isRelationEndpointTarget() && typeIsList() && !getIndexBasedListAccess()) {
+ if (getPortTarget().isRelationPortTarget() && typeIsList() && !getIndexBasedListAccess()) {
return ragconnect().defaultJavaUtilListToBytesMapping();
}
try {
@@ -312,9 +312,9 @@ aspect Mappings {
}
// --- targetTypeName ---
- syn String EndpointDefinition.targetTypeName() {
+ syn String PortDefinition.targetTypeName() {
if (getMappingList().isEmpty()) {
- return getEndpointTarget().targetTypeName();
+ return getPortTarget().targetTypeName();
} else {
if (getSend()) {
return getMappingList().get(getMappingList().size() - 1).getToType().prettyPrint();
@@ -323,12 +323,12 @@ aspect Mappings {
}
}
}
- syn String EndpointTarget.targetTypeName();
- eq AttributeEndpointTarget.targetTypeName() = getTypeName();
- eq RelationEndpointTarget.targetTypeName() = getRole().oppositeRole().targetTypeName();
- eq TokenEndpointTarget.targetTypeName() = getToken().effectiveJavaTypeUse().getName();
- eq TypeEndpointTarget.targetTypeName() = getType().getTypeDecl().getName();
- eq ContextFreeTypeEndpointTarget.targetTypeName() = getTypeDecl().getName();
+ syn String PortTarget.targetTypeName();
+ eq AttributePortTarget.targetTypeName() = getTypeName();
+ eq RelationPortTarget.targetTypeName() = getRole().oppositeRole().targetTypeName();
+ eq TokenPortTarget.targetTypeName() = getToken().effectiveJavaTypeUse().getName();
+ eq TypePortTarget.targetTypeName() = getType().getTypeDecl().getName();
+ eq ContextFreeTypePortTarget.targetTypeName() = getTypeDecl().getName();
syn String Role.targetTypeName() = getType().getName();
eq ListRole.targetTypeName() = "java.util.List<" + getType().getName() + ">";
diff --git a/ragconnect.base/src/main/jastadd/NameResolution.jrag b/ragconnect.base/src/main/jastadd/NameResolution.jrag
index 0690eca4a260b5f7396dfe2ca6905b3aa98e0aa5..e470430d8f5d355cd90d4e79503ee431de994a18 100644
--- a/ragconnect.base/src/main/jastadd/NameResolution.jrag
+++ b/ragconnect.base/src/main/jastadd/NameResolution.jrag
@@ -1,48 +1,48 @@
aspect RagConnectNameResolution {
- // --- lookupTokenEndpointDefinition ---
- inh java.util.List<EndpointDefinition> EndpointDefinition.lookupTokenEndpointDefinitions(TokenComponent token);
- inh java.util.List<EndpointDefinition> EndpointTarget.lookupTokenEndpointDefinitions(TokenComponent token);
- eq RagConnect.getConnectSpecificationFile().lookupTokenEndpointDefinitions(TokenComponent token) = lookupTokenEndpointDefinitions(token);
- syn java.util.List<EndpointDefinition> RagConnect.lookupTokenEndpointDefinitions(TokenComponent token) {
- java.util.List<EndpointDefinition> result = new java.util.ArrayList<>();
- for (EndpointTarget target : givenEndpointTargetList()) {
- if (target.isTokenEndpointTarget() && target.asTokenEndpointTarget().getToken().equals(token)) {
- result.add(target.containingEndpointDefinition());
+ // --- lookupTokenPortDefinition ---
+ inh java.util.List<PortDefinition> PortDefinition.lookupTokenPortDefinitions(TokenComponent token);
+ inh java.util.List<PortDefinition> PortTarget.lookupTokenPortDefinitions(TokenComponent token);
+ eq RagConnect.getConnectSpecificationFile().lookupTokenPortDefinitions(TokenComponent token) = lookupTokenPortDefinitions(token);
+ syn java.util.List<PortDefinition> RagConnect.lookupTokenPortDefinitions(TokenComponent token) {
+ java.util.List<PortDefinition> result = new java.util.ArrayList<>();
+ for (PortTarget target : givenPortTargetList()) {
+ if (target.isTokenPortTarget() && target.asTokenPortTarget().getToken().equals(token)) {
+ result.add(target.containingPortDefinition());
}
}
return result;
}
- // --- lookupGivenTypeEndpointDefinition ---
- inh java.util.List<EndpointDefinition> EndpointDefinition.lookupGivenTypeEndpointDefinitions(TypeComponent type);
- inh java.util.List<EndpointDefinition> EndpointTarget.lookupGivenTypeEndpointDefinitions(TypeComponent type);
- eq RagConnect.getConnectSpecificationFile().lookupGivenTypeEndpointDefinitions(TypeComponent type) = lookupTypeEndpointDefinitions(type, true);
+ // --- lookupGivenTypePortDefinition ---
+ inh java.util.List<PortDefinition> PortDefinition.lookupGivenTypePortDefinitions(TypeComponent type);
+ inh java.util.List<PortDefinition> PortTarget.lookupGivenTypePortDefinitions(TypeComponent type);
+ eq RagConnect.getConnectSpecificationFile().lookupGivenTypePortDefinitions(TypeComponent type) = lookupTypePortDefinitions(type, true);
- // --- lookupAllTypeEndpointDefinition ---
- inh java.util.List<EndpointDefinition> EndpointDefinition.lookupAllTypeEndpointDefinitions(TypeComponent type);
- inh java.util.List<EndpointDefinition> EndpointTarget.lookupAllTypeEndpointDefinitions(TypeComponent type);
- eq RagConnect.getConnectSpecificationFile().lookupAllTypeEndpointDefinitions(TypeComponent type) = lookupTypeEndpointDefinitions(type, false);
+ // --- lookupAllTypePortDefinition ---
+ inh java.util.List<PortDefinition> PortDefinition.lookupAllTypePortDefinitions(TypeComponent type);
+ inh java.util.List<PortDefinition> PortTarget.lookupAllTypePortDefinitions(TypeComponent type);
+ eq RagConnect.getConnectSpecificationFile().lookupAllTypePortDefinitions(TypeComponent type) = lookupTypePortDefinitions(type, false);
- syn java.util.List<EndpointDefinition> RagConnect.lookupTypeEndpointDefinitions(TypeComponent type, boolean onlyGiven) {
- java.util.List<EndpointDefinition> result = new java.util.ArrayList<>();
- for (EndpointDefinition def : onlyGiven ? givenEndpointDefinitionList() : allEndpointDefinitionList()) {
- EndpointTarget target = def.getEndpointTarget();
- if (target.isTypeEndpointTarget() && target.asTypeEndpointTarget().getType().equals(type)) {
+ syn java.util.List<PortDefinition> RagConnect.lookupTypePortDefinitions(TypeComponent type, boolean onlyGiven) {
+ java.util.List<PortDefinition> result = new java.util.ArrayList<>();
+ for (PortDefinition def : onlyGiven ? givenPortDefinitionList() : allPortDefinitionList()) {
+ PortTarget target = def.getPortTarget();
+ if (target.isTypePortTarget() && target.asTypePortTarget().getType().equals(type)) {
result.add(def);
}
}
return result;
}
- // --- lookupContextFreeTypeEndpointDefinition ---
- inh java.util.List<EndpointDefinition> EndpointDefinition.lookupContextFreeTypeEndpointDefinitions(TypeDecl typeDecl);
- inh java.util.List<EndpointDefinition> EndpointTarget.lookupContextFreeTypeEndpointDefinitions(TypeDecl typeDecl);
- eq RagConnect.getConnectSpecificationFile().lookupContextFreeTypeEndpointDefinitions(TypeDecl typeDecl) = lookupContextFreeTypeEndpointDefinitions(typeDecl);
- syn java.util.List<EndpointDefinition> RagConnect.lookupContextFreeTypeEndpointDefinitions(TypeDecl typeDecl) {
- java.util.List<EndpointDefinition> result = new java.util.ArrayList<>();
- for (EndpointTarget target : givenEndpointTargetList()) {
- if (target.isContextFreeTypeEndpointTarget() && target.asContextFreeTypeEndpointTarget().getTypeDecl().equals(typeDecl)) {
- result.add(target.containingEndpointDefinition());
+ // --- lookupContextFreeTypePortDefinition ---
+ inh java.util.List<PortDefinition> PortDefinition.lookupContextFreeTypePortDefinitions(TypeDecl typeDecl);
+ inh java.util.List<PortDefinition> PortTarget.lookupContextFreeTypePortDefinitions(TypeDecl typeDecl);
+ eq RagConnect.getConnectSpecificationFile().lookupContextFreeTypePortDefinitions(TypeDecl typeDecl) = lookupContextFreeTypePortDefinitions(typeDecl);
+ syn java.util.List<PortDefinition> RagConnect.lookupContextFreeTypePortDefinitions(TypeDecl typeDecl) {
+ java.util.List<PortDefinition> result = new java.util.ArrayList<>();
+ for (PortTarget target : givenPortTargetList()) {
+ if (target.isContextFreeTypePortTarget() && target.asContextFreeTypePortTarget().getTypeDecl().equals(typeDecl)) {
+ result.add(target.containingPortDefinition());
}
}
return result;
@@ -59,15 +59,15 @@ aspect RagConnectNameResolution {
return null;
}
- // rel EndpointDefinition.Mapping* -> MappingDefinition
- refine RefResolverStubs eq EndpointDefinition.resolveMappingByToken(String id, int position) {
+ // rel PortDefinition.Mapping* -> MappingDefinition
+ refine RefResolverStubs eq PortDefinition.resolveMappingByToken(String id, int position) {
MappingDefinition result = tryResolveMappingByToken(id);
if (result == null) {
System.err.println("Could not resolve MappingDefinition '" + id + "'.");
}
return result;
}
- syn MappingDefinition EndpointDefinition.tryResolveMappingByToken(String id) {
+ syn MappingDefinition PortDefinition.tryResolveMappingByToken(String id) {
for (MappingDefinition mappingDefinition : ragconnect().givenMappingDefinitionList()) {
if (mappingDefinition.getID().equals(id)) {
return mappingDefinition;
diff --git a/ragconnect.base/src/main/jastadd/Navigation.jrag b/ragconnect.base/src/main/jastadd/Navigation.jrag
index 02f6f23ee92d2ab61a60a87928ef45921602484c..08ef63ff423d9146cb33287487d652e52df5ce57 100644
--- a/ragconnect.base/src/main/jastadd/Navigation.jrag
+++ b/ragconnect.base/src/main/jastadd/Navigation.jrag
@@ -1,40 +1,40 @@
aspect GeneratedNavigation {
- /** Tests if EndpointTarget is a TokenEndpointTarget.
- * @return 'true' if this is a TokenEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a TokenPortTarget.
+ * @return 'true' if this is a TokenPortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isTokenEndpointTarget() = false;
- eq TokenEndpointTarget.isTokenEndpointTarget() = true;
+ syn boolean PortTarget.isTokenPortTarget() = false;
+ eq TokenPortTarget.isTokenPortTarget() = true;
- /** Tests if EndpointTarget is a TypeEndpointTarget.
- * @return 'true' if this is a TypeEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a TypePortTarget.
+ * @return 'true' if this is a TypePortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isTypeEndpointTarget() = false;
- eq TypeEndpointTarget.isTypeEndpointTarget() = true;
+ syn boolean PortTarget.isTypePortTarget() = false;
+ eq TypePortTarget.isTypePortTarget() = true;
- /** Tests if EndpointTarget is a ContextFreeTypeEndpointTarget.
- * @return 'true' if this is a ContextFreeTypeEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a ContextFreeTypePortTarget.
+ * @return 'true' if this is a ContextFreeTypePortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isContextFreeTypeEndpointTarget() = false;
- eq ContextFreeTypeEndpointTarget.isContextFreeTypeEndpointTarget() = true;
+ syn boolean PortTarget.isContextFreeTypePortTarget() = false;
+ eq ContextFreeTypePortTarget.isContextFreeTypePortTarget() = true;
- /** Tests if EndpointTarget is a UntypedEndpointTarget.
- * @return 'true' if this is a UntypedEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a UntypedPortTarget.
+ * @return 'true' if this is a UntypedPortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isUntypedEndpointTarget() = false;
- eq UntypedEndpointTarget.isUntypedEndpointTarget() = true;
+ syn boolean PortTarget.isUntypedPortTarget() = false;
+ eq UntypedPortTarget.isUntypedPortTarget() = true;
- /** Tests if EndpointTarget is a AttributeEndpointTarget.
- * @return 'true' if this is a AttributeEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a AttributePortTarget.
+ * @return 'true' if this is a AttributePortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isAttributeEndpointTarget() = false;
- eq AttributeEndpointTarget.isAttributeEndpointTarget() = true;
+ syn boolean PortTarget.isAttributePortTarget() = false;
+ eq AttributePortTarget.isAttributePortTarget() = true;
- /** Tests if EndpointTarget is a RelationEndpointTarget.
- * @return 'true' if this is a RelationEndpointTarget, otherwise 'false'
+ /** Tests if PortTarget is a RelationPortTarget.
+ * @return 'true' if this is a RelationPortTarget, otherwise 'false'
*/
- syn boolean EndpointTarget.isRelationEndpointTarget() = false;
- eq RelationEndpointTarget.isRelationEndpointTarget() = true;
+ syn boolean PortTarget.isRelationPortTarget() = false;
+ eq RelationPortTarget.isRelationPortTarget() = true;
/** Tests if TemplateDefaultMappingDefinition is a SerializeListMapping.
* @return 'true' if this is a SerializeListMapping, otherwise 'false'
@@ -54,47 +54,47 @@ aspect GeneratedNavigation {
syn boolean TemplateDefaultMappingDefinition.isDeserializeListMapping() = false;
eq DeserializeListMapping.isDeserializeListMapping() = true;
- /** casts a EndpointTarget into a TokenEndpointTarget if possible.
- * @return 'this' cast to a TokenEndpointTarget or 'null'
+ /** casts a PortTarget into a TokenPortTarget if possible.
+ * @return 'this' cast to a TokenPortTarget or 'null'
*/
- syn TokenEndpointTarget EndpointTarget.asTokenEndpointTarget();
- eq EndpointTarget.asTokenEndpointTarget() = null;
- eq TokenEndpointTarget.asTokenEndpointTarget() = this;
+ syn TokenPortTarget PortTarget.asTokenPortTarget();
+ eq PortTarget.asTokenPortTarget() = null;
+ eq TokenPortTarget.asTokenPortTarget() = this;
- /** casts a EndpointTarget into a TypeEndpointTarget if possible.
- * @return 'this' cast to a TypeEndpointTarget or 'null'
+ /** casts a PortTarget into a TypePortTarget if possible.
+ * @return 'this' cast to a TypePortTarget or 'null'
*/
- syn TypeEndpointTarget EndpointTarget.asTypeEndpointTarget();
- eq EndpointTarget.asTypeEndpointTarget() = null;
- eq TypeEndpointTarget.asTypeEndpointTarget() = this;
+ syn TypePortTarget PortTarget.asTypePortTarget();
+ eq PortTarget.asTypePortTarget() = null;
+ eq TypePortTarget.asTypePortTarget() = this;
- /** casts a EndpointTarget into a ContextFreeTypeEndpointTarget if possible.
- * @return 'this' cast to a ContextFreeTypeEndpointTarget or 'null'
+ /** casts a PortTarget into a ContextFreeTypePortTarget if possible.
+ * @return 'this' cast to a ContextFreeTypePortTarget or 'null'
*/
- syn ContextFreeTypeEndpointTarget EndpointTarget.asContextFreeTypeEndpointTarget();
- eq EndpointTarget.asContextFreeTypeEndpointTarget() = null;
- eq ContextFreeTypeEndpointTarget.asContextFreeTypeEndpointTarget() = this;
+ syn ContextFreeTypePortTarget PortTarget.asContextFreeTypePortTarget();
+ eq PortTarget.asContextFreeTypePortTarget() = null;
+ eq ContextFreeTypePortTarget.asContextFreeTypePortTarget() = this;
- /** casts a EndpointTarget into a UntypedEndpointTarget if possible.
- * @return 'this' cast to a UntypedEndpointTarget or 'null'
+ /** casts a PortTarget into a UntypedPortTarget if possible.
+ * @return 'this' cast to a UntypedPortTarget or 'null'
*/
- syn UntypedEndpointTarget EndpointTarget.asUntypedEndpointTarget();
- eq EndpointTarget.asUntypedEndpointTarget() = null;
- eq UntypedEndpointTarget.asUntypedEndpointTarget() = this;
+ syn UntypedPortTarget PortTarget.asUntypedPortTarget();
+ eq PortTarget.asUntypedPortTarget() = null;
+ eq UntypedPortTarget.asUntypedPortTarget() = this;
- /** casts a EndpointTarget into a AttributeEndpointTarget if possible.
- * @return 'this' cast to a AttributeEndpointTarget or 'null'
+ /** casts a PortTarget into a AttributePortTarget if possible.
+ * @return 'this' cast to a AttributePortTarget or 'null'
*/
- syn AttributeEndpointTarget EndpointTarget.asAttributeEndpointTarget();
- eq EndpointTarget.asAttributeEndpointTarget() = null;
- eq AttributeEndpointTarget.asAttributeEndpointTarget() = this;
+ syn AttributePortTarget PortTarget.asAttributePortTarget();
+ eq PortTarget.asAttributePortTarget() = null;
+ eq AttributePortTarget.asAttributePortTarget() = this;
- /** casts a EndpointTarget into a RelationEndpointTarget if possible.
- * @return 'this' cast to a RelationEndpointTarget or 'null'
+ /** casts a PortTarget into a RelationPortTarget if possible.
+ * @return 'this' cast to a RelationPortTarget or 'null'
*/
- syn RelationEndpointTarget EndpointTarget.asRelationEndpointTarget();
- eq EndpointTarget.asRelationEndpointTarget() = null;
- eq RelationEndpointTarget.asRelationEndpointTarget() = this;
+ syn RelationPortTarget PortTarget.asRelationPortTarget();
+ eq PortTarget.asRelationPortTarget() = null;
+ eq RelationPortTarget.asRelationPortTarget() = this;
}
aspect RagConnectNavigation {
@@ -119,9 +119,9 @@ aspect RagConnectNavigation {
eq Program.getChild().containedConnectSpecification() = null;
eq ConnectSpecification.getChild().containedConnectSpecification() = this;
- // --- containingEndpointDefinition ---
- inh EndpointDefinition EndpointTarget.containingEndpointDefinition();
- eq EndpointDefinition.getEndpointTarget().containingEndpointDefinition() = this;
+ // --- containingPortDefinition ---
+ inh PortDefinition PortTarget.containingPortDefinition();
+ eq PortDefinition.getPortTarget().containingPortDefinition() = this;
// --- containedFile
eq RagConnect.getChild().containedFile() = null;
@@ -137,11 +137,11 @@ aspect RagConnectNavigation {
}
- //--- givenEndpointTargetList ---
- syn List<EndpointTarget> RagConnect.givenEndpointTargetList() {
- List<EndpointTarget> result = new ArrayList<>();
+ //--- givenPortTargetList ---
+ syn List<PortTarget> RagConnect.givenPortTargetList() {
+ List<PortTarget> result = new ArrayList<>();
for (ConnectSpecification spec : getConnectSpecificationFileList()) {
- spec.getEndpointDefinitionList().forEach(endpointDef -> result.add(endpointDef.getEndpointTarget()));
+ spec.getPortDefinitionList().forEach(portDef -> result.add(portDef.getPortTarget()));
}
return result;
}
diff --git a/ragconnect.base/src/main/jastadd/RagConnect.relast b/ragconnect.base/src/main/jastadd/RagConnect.relast
index ef96abf63729ff856b65a3f108c44b5b01fe7ecb..7282bb3fda5771c3b1ea87a4bfae235c3950b640 100644
--- a/ragconnect.base/src/main/jastadd/RagConnect.relast
+++ b/ragconnect.base/src/main/jastadd/RagConnect.relast
@@ -1,23 +1,23 @@
RagConnect ::= ConnectSpecificationFile* Program Handler* Configuration;
-abstract ConnectSpecification ::= EndpointDefinition* DependencyDefinition* MappingDefinition*;
+abstract ConnectSpecification ::= PortDefinition* DependencyDefinition* MappingDefinition*;
ConnectSpecificationFile : ConnectSpecification ::= <FileName>;
-EndpointDefinition ::= <AlwaysApply:boolean> <IndexBasedListAccess:boolean> <WithAdd:boolean> <Send:boolean> EndpointTarget;
-rel EndpointDefinition.Mapping* <-> MappingDefinition.UsedAt*;
+PortDefinition ::= <AlwaysApply:boolean> <IndexBasedListAccess:boolean> <WithAdd:boolean> <Send:boolean> PortTarget;
+rel PortDefinition.Mapping* <-> MappingDefinition.UsedAt*;
-abstract EndpointTarget;
-TokenEndpointTarget : EndpointTarget;
-rel TokenEndpointTarget.Token <-> TokenComponent.TokenEndpointTarget*;
-TypeEndpointTarget : EndpointTarget;
-rel TypeEndpointTarget.Type <-> TypeComponent.TypeEndpointTarget*;
-ContextFreeTypeEndpointTarget : EndpointTarget;
-rel ContextFreeTypeEndpointTarget.TypeDecl <-> TypeDecl.ContextFreeTypeEndpointTarget*;
-AttributeEndpointTarget : EndpointTarget ::= <Name> <TypeName> ;
-rel AttributeEndpointTarget.ParentTypeDecl <-> TypeDecl.AttributeEndpointTarget*;
-RelationEndpointTarget : EndpointTarget ;
-rel RelationEndpointTarget.Role <-> NavigableRole.RelationEndpointTarget* ;
-UntypedEndpointTarget : EndpointTarget ::= <TypeName> <ChildName> <IsAttribute:boolean>; // only used by parser
+abstract PortTarget;
+TokenPortTarget : PortTarget;
+rel TokenPortTarget.Token <-> TokenComponent.TokenPortTarget*;
+TypePortTarget : PortTarget;
+rel TypePortTarget.Type <-> TypeComponent.TypePortTarget*;
+ContextFreeTypePortTarget : PortTarget;
+rel ContextFreeTypePortTarget.TypeDecl <-> TypeDecl.ContextFreeTypePortTarget*;
+AttributePortTarget : PortTarget ::= <Name> <TypeName> ;
+rel AttributePortTarget.ParentTypeDecl <-> TypeDecl.AttributePortTarget*;
+RelationPortTarget : PortTarget ;
+rel RelationPortTarget.Role <-> NavigableRole.RelationPortTarget* ;
+UntypedPortTarget : PortTarget ::= <TypeName> <ChildName> <IsAttribute:boolean>; // only used by parser
DependencyDefinition ::= <ID>;
rel DependencyDefinition.Source <-> TokenComponent.DependencySourceDefinition*;
diff --git a/ragconnect.base/src/main/jastadd/Warnings.jrag b/ragconnect.base/src/main/jastadd/Warnings.jrag
index 351fb19eac5a41930c7e8ba64aa6b151bdcf7d78..76ca00169039bde4cc04e896d36e94a7694008d9 100644
--- a/ragconnect.base/src/main/jastadd/Warnings.jrag
+++ b/ragconnect.base/src/main/jastadd/Warnings.jrag
@@ -7,7 +7,7 @@ aspect Warnings {
when ragconnect().configIncrementalOptionActive()
to RagConnect.warnings();
- EndpointDefinition contributes warning("No dependency definitions are given, and incremental evaluation is disabled. No messages will be sent for this!")
+ PortDefinition contributes warning("No dependency definitions are given, and incremental evaluation is disabled. No messages will be sent for this!")
when getSend() && ragconnect().allDependencyDefinitionList().isEmpty() && !ragconnect().configIncrementalOptionActive()
to RagConnect.warnings();
diff --git a/ragconnect.base/src/main/jastadd/parser/ParserRewrites.jrag b/ragconnect.base/src/main/jastadd/parser/ParserRewrites.jrag
index 70f778c7b8f63b86d2d60bf0d71d1beb6cdeb41e..364161d52e019d3d72393d277a8d4f71a25d19b5 100644
--- a/ragconnect.base/src/main/jastadd/parser/ParserRewrites.jrag
+++ b/ragconnect.base/src/main/jastadd/parser/ParserRewrites.jrag
@@ -1,40 +1,40 @@
aspect ParserRewrites {
- rewrite UntypedEndpointTarget {
+ rewrite UntypedPortTarget {
when (getChildName() != null && tryGloballyResolveTypeComponentByToken(combinedName()) != null)
- to TypeEndpointTarget {
- TypeEndpointTarget result = new TypeEndpointTarget();
+ to TypePortTarget {
+ TypePortTarget result = new TypePortTarget();
result.copyOtherValuesFrom(this);
result.setType(TypeComponent.createRef(this.combinedName()));
return result;
}
when (getChildName() != null && tryGloballyResolveTokenComponentByToken(combinedName()) != null)
- to TokenEndpointTarget {
- TokenEndpointTarget result = new TokenEndpointTarget();
+ to TokenPortTarget {
+ TokenPortTarget result = new TokenPortTarget();
result.copyOtherValuesFrom(this);
result.setToken(TokenComponent.createRef(this.combinedName()));
return result;
}
when (getChildName() != null && tryGloballyResolveNavigableRoleByToken(combinedName()) != null)
- to RelationEndpointTarget {
- RelationEndpointTarget result = new RelationEndpointTarget();
+ to RelationPortTarget {
+ RelationPortTarget result = new RelationPortTarget();
result.copyOtherValuesFrom(this);
result.setRole(NavigableRole.createRef(this.combinedName()));
return result;
}
when (getChildName() == "")
- to ContextFreeTypeEndpointTarget {
- ContextFreeTypeEndpointTarget result = new ContextFreeTypeEndpointTarget();
+ to ContextFreeTypePortTarget {
+ ContextFreeTypePortTarget result = new ContextFreeTypePortTarget();
result.copyOtherValuesFrom(this);
result.setTypeDecl(TypeDecl.createRef(getTypeName()));
return result;
}
when (getIsAttribute())
- to AttributeEndpointTarget {
- AttributeEndpointTarget result = new AttributeEndpointTarget();
+ to AttributePortTarget {
+ AttributePortTarget result = new AttributePortTarget();
String[] tokens = this.getChildName().split(":");
String attributeName = tokens[0];
String attributeTypeName = tokens[1];
@@ -46,19 +46,19 @@ aspect ParserRewrites {
}
}
- syn String UntypedEndpointTarget.combinedName() = getTypeName() + "." + getChildName();
+ syn String UntypedPortTarget.combinedName() = getTypeName() + "." + getChildName();
- protected void EndpointTarget.copyOtherValuesFrom(EndpointTarget source) {
+ protected void PortTarget.copyOtherValuesFrom(PortTarget source) {
this.setStart(source.getStartLine(), source.getStartColumn());
this.setEnd(source.getEndLine(), source.getEndColumn());
}
- eq UntypedEndpointTarget.senderName() = "<untyped.senderName>";
- eq UntypedEndpointTarget.getterMethodName() = "<untyped.getterMethodName>";
- eq UntypedEndpointTarget.parentTypeName() = "<untyped.parentTypeName>";
- eq UntypedEndpointTarget.entityName() = "<untyped.entityName>";
- eq UntypedEndpointTarget.isAlreadyDefined() = false;
- eq UntypedEndpointTarget.hasAttributeResetMethod() = false;
- eq UntypedEndpointTarget.targetTypeName() = "<untyped.targetTypeName>";
- eq UntypedEndpointTarget.isTypeEndpointTarget() = false;
+ eq UntypedPortTarget.senderName() = "<untyped.senderName>";
+ eq UntypedPortTarget.getterMethodName() = "<untyped.getterMethodName>";
+ eq UntypedPortTarget.parentTypeName() = "<untyped.parentTypeName>";
+ eq UntypedPortTarget.entityName() = "<untyped.entityName>";
+ eq UntypedPortTarget.isAlreadyDefined() = false;
+ eq UntypedPortTarget.hasAttributeResetMethod() = false;
+ eq UntypedPortTarget.targetTypeName() = "<untyped.targetTypeName>";
+ eq UntypedPortTarget.isTypePortTarget() = false;
}
diff --git a/ragconnect.base/src/main/jastadd/parser/RagConnect.parser b/ragconnect.base/src/main/jastadd/parser/RagConnect.parser
index 55eac248e5f48d39aa38db6ac3cd20df61930220..f20588bb5d6cf82fe09f6a525dab543d53340f0d 100644
--- a/ragconnect.base/src/main/jastadd/parser/RagConnect.parser
+++ b/ragconnect.base/src/main/jastadd/parser/RagConnect.parser
@@ -1,7 +1,7 @@
ConnectSpecificationFile connect_specification_file
- = endpoint_definition.d connect_specification_file.r
+ = port_definition.d connect_specification_file.r
{:
- r.getEndpointDefinitionList().insertChild(d, 0); return r;
+ r.getPortDefinitionList().insertChild(d, 0); return r;
:}
| dependency_definition.d connect_specification_file.r
{:
@@ -22,50 +22,50 @@ ConnectSpecificationFile connect_specification_file
private Iterable<String> makeMappingDefs(ArrayList<?> raw_mapping_defs) {
return () -> raw_mapping_defs.stream().map(raw -> ((Symbol) raw).value.toString()).iterator();
}
-// private TokenEndpointDefinition enableAlwaysApply(TokenEndpointDefinition def) {
+// private TokenPortDefinition enableAlwaysApply(TokenPortDefinition def) {
// def.setAlwaysApply(true);
// return def;
// }
- private EndpointDefinition createEndpointDefinition(
- EndpointTarget endpointTarget, boolean send,
+ private PortDefinition createPortDefinition(
+ PortTarget portTarget, boolean send,
boolean indexBasedListAccess, boolean withAdd) {
- EndpointDefinition result = new EndpointDefinition();
+ PortDefinition result = new PortDefinition();
result.setSend(send);
result.setIndexBasedListAccess(indexBasedListAccess);
result.setWithAdd(withAdd);
- result.setEndpointTarget(endpointTarget);
+ result.setPortTarget(portTarget);
return result;
}
:} ;
-EndpointDefinition endpoint_definition
- = endpoint_definition_type.endpointDef SCOL
+PortDefinition port_definition
+ = port_definition_type.portDef SCOL
{:
- return endpointDef;
+ return portDef;
:}
- | endpoint_definition_type.endpointDef USING string_list.mapping_defs SCOL
+ | port_definition_type.portDef USING string_list.mapping_defs SCOL
{:
for (String mapping_def : makeMappingDefs(mapping_defs)) {
- endpointDef.addMapping(MappingDefinition.createRef(mapping_def));
+ portDef.addMapping(MappingDefinition.createRef(mapping_def));
}
- return endpointDef;
+ return portDef;
:}
;
-EndpointDefinition endpoint_definition_type
- = SEND endpoint_target.t {: return createEndpointDefinition(t, true, false, false); :}
- | SEND INDEXED endpoint_target.t {: return createEndpointDefinition(t, true, true, false); :}
- | RECEIVE endpoint_target.t {: return createEndpointDefinition(t, false, false, false); :}
- | RECEIVE INDEXED endpoint_target.t {: return createEndpointDefinition(t, false, true, false); :}
- | RECEIVE WITH ADD endpoint_target.t {: return createEndpointDefinition(t, false, false, true ); :}
- | RECEIVE INDEXED WITH ADD endpoint_target.t {: return createEndpointDefinition(t, false, true, true ); :}
+PortDefinition port_definition_type
+ = SEND port_target.t {: return createPortDefinition(t, true, false, false); :}
+ | SEND INDEXED port_target.t {: return createPortDefinition(t, true, true, false); :}
+ | RECEIVE port_target.t {: return createPortDefinition(t, false, false, false); :}
+ | RECEIVE INDEXED port_target.t {: return createPortDefinition(t, false, true, false); :}
+ | RECEIVE WITH ADD port_target.t {: return createPortDefinition(t, false, false, true ); :}
+ | RECEIVE INDEXED WITH ADD port_target.t {: return createPortDefinition(t, false, true, true ); :}
;
-EndpointTarget endpoint_target
- = ID.type_name DOT ID.child_name {: return new UntypedEndpointTarget(type_name, child_name, false); :}
+PortTarget port_target
+ = ID.type_name DOT ID.child_name {: return new UntypedPortTarget(type_name, child_name, false); :}
| ID.type_name DOT ID.child_name BRACKET_LEFT java_type_use.attribute_type_name BRACKET_RIGHT
- {: return new UntypedEndpointTarget(type_name, child_name + ":" + attribute_type_name.prettyPrint(), true); :}
- | ID.type_name {: return new UntypedEndpointTarget(type_name, "", false); :}
+ {: return new UntypedPortTarget(type_name, child_name + ":" + attribute_type_name.prettyPrint(), true); :}
+ | ID.type_name {: return new UntypedPortTarget(type_name, "", false); :}
;
ArrayList string_list
diff --git a/ragconnect.base/src/main/resources/ListAspect.mustache b/ragconnect.base/src/main/resources/ListAspect.mustache
deleted file mode 100644
index e7ec88e5e579e7a7b50bbeb83d0779bc64203991..0000000000000000000000000000000000000000
--- a/ragconnect.base/src/main/resources/ListAspect.mustache
+++ /dev/null
@@ -1,37 +0,0 @@
-{{#hasTreeListEndpoints}}
-public void {{configJastAddList}}.serialize(com.fasterxml.jackson.core.JsonGenerator g) throws SerializationException {
- try {
- g.writeStartArray();
- for (T child : this) {
- child.serialize(g);
- }
- g.writeEndArray();
- } catch (java.io.IOException e) {
- throw new SerializationException("unable to serialize {{configJastAddList}}", e);
- }
-}
-
-protected static <T extends ASTNode> void ASTNode.serializeJavaUtilList(
- java.util.List<T> input, com.fasterxml.jackson.core.JsonGenerator g) throws SerializationException {
- try {
- g.writeStartArray();
- for (T child : input) {
- child.serialize(g);
- }
- g.writeEndArray();
- } catch (java.io.IOException e) {
- throw new SerializationException("unable to serialize list", e);
- }
-}
-
-{{#typesForReceivingListEndpoints}}
-public static {{configJastAddList}}<{{Name}}> {{Name}}.deserializeList(com.fasterxml.jackson.databind.node.ArrayNode node) throws DeserializationException {
- {{configJastAddList}}<{{Name}}> result = new {{configJastAddList}}<>();
- for (java.util.Iterator<com.fasterxml.jackson.databind.JsonNode> it = node.elements(); it.hasNext();) {
- com.fasterxml.jackson.databind.JsonNode element = it.next();
- result.add(deserialize(element));
- }
- return result;
-}
-{{/typesForReceivingListEndpoints}}
-{{/hasTreeListEndpoints}}
diff --git a/ragconnect.base/src/main/resources/ragconnect.mustache b/ragconnect.base/src/main/resources/ragconnect.mustache
index df44d40a8755dd48c796a40b4fdb2e9c3c26827d..5bd0166a46bb6f02be2df10a2bfd26b9cc63d508 100644
--- a/ragconnect.base/src/main/resources/ragconnect.mustache
+++ b/ragconnect.base/src/main/resources/ragconnect.mustache
@@ -1,13 +1,13 @@
{{> handler}}
aspect RagConnect {
- {{#allEndpointDefinitionList}}
+ {{#allPortDefinitionList}}
{{#Send}}
{{> sendDefinition}}
{{/Send}}
{{^Send}}
{{> receiveDefinition}}
{{/Send}}
- {{/allEndpointDefinitionList}}
+ {{/allPortDefinitionList}}
class RagConnectRejectMappingException extends RuntimeException {}
private static void ASTNode.reject() {
@@ -26,9 +26,9 @@ aspect RagConnect {
{{> tokenComponent}}
{{/tokenComponentsThatNeedProxy}}
- {{#typeDeclsOfContextFreeEndpointTargets}}
+ {{#typeDeclsOfContextFreePortTargets}}
{{> typeDecl}}
- {{/typeDeclsOfContextFreeEndpointTargets}}
+ {{/typeDeclsOfContextFreePortTargets}}
{{! --- touchedTerminals ---}}
{{#allTypeDecls}}
diff --git a/ragconnect.base/src/main/resources/receiveDefinition.mustache b/ragconnect.base/src/main/resources/receiveDefinition.mustache
index f4b6c301c0df4f209ad2e5e84b74049791ed63f9..b2e05ce6b2ce246b5225b98eecc7779bf3b0cfa0 100644
--- a/ragconnect.base/src/main/resources/receiveDefinition.mustache
+++ b/ragconnect.base/src/main/resources/receiveDefinition.mustache
@@ -12,7 +12,7 @@ private int {{parentTypeName}}.{{resolveInListMethodName}}(String topic) {
{{/typeIsList}}
/**
- * Connects the receive endpoint {{entityName}}.
+ * Connects the receive port {{entityName}}.
{{#typeIsList}}{{#WithAdd}}
* New values are appended to the end of the list.
{{/WithAdd}}{{/typeIsList}}
@@ -29,7 +29,7 @@ public boolean {{parentTypeName}}.{{connectMethodName}}(String {{connectParamete
{{#configLoggingEnabledForReads}}
{{logDebug}}("[Receive] {{log_}} -> {{entityName}} = {{log_}}", {{connectParameterName}}, {{lastResult}});
{{/configLoggingEnabledForReads}}
-{{#hasTypeEndpointTarget}}
+{{#hasTypePortTarget}}
{{lastResult}}.treeResolveAll();
{{#typeIsList}}
{{^IndexBasedListAccess}}
@@ -53,10 +53,10 @@ public boolean {{parentTypeName}}.{{connectMethodName}}(String {{connectParamete
{{^typeIsList}}
set{{entityName}}({{lastResult}});
{{/typeIsList}}
-{{/hasTypeEndpointTarget}}
-{{^hasTypeEndpointTarget}}
+{{/hasTypePortTarget}}
+{{^hasTypePortTarget}}
set{{entityName}}({{lastResult}});
-{{/hasTypeEndpointTarget}}
+{{/hasTypePortTarget}}
{{#configEvaluationCounter}}
{{evaluationCounterVariable}}.incrementReceive("{{parentTypeName}}", "{{entityName}}");
{{/configEvaluationCounter}}
@@ -66,7 +66,7 @@ public boolean {{parentTypeName}}.{{connectMethodName}}(String {{connectParamete
{{#typeIsList}}{{#IndexBasedListAccess}}{{^WithAdd}}
/**
- * Connects the receive endpoint {{entityName}} using a "wildcard" URI (if supported by the chosen protocol).
+ * Connects the receive port {{entityName}} using a "wildcard" URI (if supported by the chosen protocol).
* @param {{connectParameterName}} string describing protocol and path as an URI
* @return true if connect was successful, false otherwise
* @throws java.io.IOException if connect failed
diff --git a/ragconnect.base/src/main/resources/sendDefinition.mustache b/ragconnect.base/src/main/resources/sendDefinition.mustache
index 5566a252ef8f10afdd3e8b65d990cdb8d6d9a17d..9c7dac4fc7a9bccc449fcdfced102c4ba865fbb2 100644
--- a/ragconnect.base/src/main/resources/sendDefinition.mustache
+++ b/ragconnect.base/src/main/resources/sendDefinition.mustache
@@ -161,19 +161,19 @@ protected void {{parentTypeName}}.{{writeMethodName}}({{#IndexBasedListAccess}}i
{{#needForwarding}}
syn {{{forwardingType}}} {{parentTypeName}}.{{forwardingName}}({{#IndexBasedListAccess}}int index{{/IndexBasedListAccess}}) {
-{{#relationEndpointWithListRole}}
+{{#relationPortWithListRole}}
// for (var element : {{realGetterMethodCall}}) {
// element.{{touchedTerminalsMethodName}}();
// }
{{realGetterMethodCall}}.stream().forEach(element -> element.{{touchedTerminalsMethodName}}());
return {{realGetterMethodCall}};
-{{/relationEndpointWithListRole}}
-{{^relationEndpointWithListRole}}
+{{/relationPortWithListRole}}
+{{^relationPortWithListRole}}
{{{forwardingType}}} result = {{realGetterMethodCall}};
if (result == null) {
return null;
}
return result.{{touchedTerminalsMethodName}}();
-{{/relationEndpointWithListRole}}
+{{/relationPortWithListRole}}
}
{{/needForwarding}}
diff --git a/ragconnect.base/src/main/resources/tokenComponent.mustache b/ragconnect.base/src/main/resources/tokenComponent.mustache
index 3b0ae62080f39f17a329a34caeb410da66365f5d..12238f4428bf2ef79951015425cf45285cca624b 100644
--- a/ragconnect.base/src/main/resources/tokenComponent.mustache
+++ b/ragconnect.base/src/main/resources/tokenComponent.mustache
@@ -2,11 +2,11 @@ public {{parentTypeName}} {{parentTypeName}}.set{{Name}}({{javaType}} value) {
set{{internalName}}(value);
{{#DependencySourceDefinitions}}
for ({{targetParentTypeName}} target : get{{internalRelationPrefix}}TargetList()) {
- {{#targetEndpointDefinition}}
+ {{#targetPortDefinition}}
if (target.{{updateMethodName}}()) {
target.{{writeMethodName}}();
}
- {{/targetEndpointDefinition}}
+ {{/targetPortDefinition}}
}
{{/DependencySourceDefinitions}}
{{#normalTokenSendDef}}
diff --git a/ragconnect.base/src/main/resources/typeDecl.mustache b/ragconnect.base/src/main/resources/typeDecl.mustache
index 1f674da36852786afab198b086b39b3cbf543b7b..95cb3ee84d3df8f86111efbbfcc2bf61a06dab6e 100644
--- a/ragconnect.base/src/main/resources/typeDecl.mustache
+++ b/ragconnect.base/src/main/resources/typeDecl.mustache
@@ -14,11 +14,11 @@ inh int {{Name}}._ragconnect_myIndexInList();
{{/isListComponent}}
{{/occurencesInProductionRules}}
-{{#ContextFreeTypeEndpointTargets}}{{#containingEndpointDefinition}}
+{{#ContextFreeTypePortTargets}}{{#containingPortDefinition}}
public boolean {{Name}}.{{connectMethodName}}(String {{connectParameterName}}{{#Send}}, boolean writeCurrentValue{{/Send}}) throws java.io.IOException {
switch (_ragconnect_myContext()) {
{{#occurencesInProductionRules}}
- {{!TODO only using "connectMethodName" is not correct, since the actual name might be different, e.g., if both send and receive are defined. need a reference to the actual endpoint-definition here}}
+ {{!TODO only using "connectMethodName" is not correct, since the actual name might be different, e.g., if both send and receive are defined. need a reference to the actual port-definition here}}
{{^isListComponent}}
case "{{parentTypeName}}.{{Name}}": return (({{parentTypeName}}) _ragconnect_myParent()).{{connectMethodName}}{{Name}}({{connectParameterName}}{{#Send}}, writeCurrentValue{{/Send}});
{{/isListComponent}}
@@ -42,4 +42,4 @@ public boolean {{Name}}.{{disconnectMethodName}}(String {{connectParameterName}}
return false;
}
}
-{{/containingEndpointDefinition}}{{/ContextFreeTypeEndpointTargets}}
+{{/containingPortDefinition}}{{/ContextFreeTypePortTargets}}
diff --git a/ragconnect.tests/src/test/01-input/errors/Errors.relast b/ragconnect.tests/src/test/01-input/errors/Errors.relast
index dd3fc0faf5bea8d4718f4cc429605758fb2bd972..85e14e3a44d5ea950498f6d4fa092d2aa4fe4be0 100644
--- a/ragconnect.tests/src/test/01-input/errors/Errors.relast
+++ b/ragconnect.tests/src/test/01-input/errors/Errors.relast
@@ -14,5 +14,5 @@ D ::= <SourceNonExistingTarget>
<SourceDoubledValue> /<TargetDoubledValue>/
MyList:D* ;
-// context-free endpoints
+// context-free ports
E ::= ;
diff --git a/ragconnect.tests/src/test/01-input/errors/Part.expected b/ragconnect.tests/src/test/01-input/errors/Part.expected
index d5e2f0db2b1f5a20af7e4ceb50741c6d8e4dce45..7c212f1fff58e2d1e15f5090485c807ae376f6ef 100644
--- a/ragconnect.tests/src/test/01-input/errors/Part.expected
+++ b/ragconnect.tests/src/test/01-input/errors/Part.expected
@@ -1,11 +1,11 @@
-Part1.connect Line 3, column 1: Endpoint definition already defined for B.DoubledValue
-Part1.connect Line 4, column 1: Endpoint definition already defined for B.DoubledValue
+Part1.connect Line 3, column 1: Port definition already defined for B.DoubledValue
+Part1.connect Line 4, column 1: Port definition already defined for B.DoubledValue
Part1.connect Line 10, column 1: Receiving target token must not be an NTA token!
Part1.connect Line 13, column 1: No suitable default mapping found for type java.util.List<String>
Part1.connect Line 16, column 1: to-type of last mapping (java.util.List<String>) not assignable to type of the token (String)!
Part1.connect Line 19, column 1: to-type of last mapping (int) not assignable to type of the token (String)!
-Part1.connect Line 26, column 6: Could not resolve endpoint target C.ErrorNotResolved
-Part2.connect Line 5, column 1: Endpoint definition already defined for C.DoubledValue
-Part2.connect Line 6, column 1: Endpoint definition already defined for C.DoubledValue
+Part1.connect Line 26, column 6: Could not resolve port target C.ErrorNotResolved
+Part2.connect Line 5, column 1: Port definition already defined for C.DoubledValue
+Part2.connect Line 6, column 1: Port definition already defined for C.DoubledValue
Part2.connect Line 17, column 1: The name of a dependency definition must not be equal to a list-node on the source
Part2.connect Line 22, column 1: Dependency definition already defined for D with name DoubledValue
diff --git a/ragconnect.tests/src/test/01-input/errors/Standard.connect b/ragconnect.tests/src/test/01-input/errors/Standard.connect
index fb2c7cb2400d1b8ca44903a9aeb3bb0bfcf28537..68a31b844473634bfaca48d04dd177ce9c2133d3 100644
--- a/ragconnect.tests/src/test/01-input/errors/Standard.connect
+++ b/ragconnect.tests/src/test/01-input/errors/Standard.connect
@@ -18,10 +18,10 @@ receive B.ErrorTypeOfLastMapping using StringToString, StringToList ;
// Error: types of mappings must match (modulo inheritance)
receive B.ErrorTypeMismatch using StringToList, IntToInt ;
-// Error: Context-Free endpoint not allowed for root nodes
+// Error: Context-Free port not allowed for root nodes
receive A;
-// Error: Clash with implied endpoint definition of context-free endpoint
+// Error: Clash with implied port definition of context-free port
receive E;
receive A.E;
@@ -63,7 +63,7 @@ send D.TargetDoubledValue;
// non-existence of attributes is not checked by RagConnect
send A.nonExistingAttribute(int);
-// Already defined endpoints for attributes will be reported, however
+// Already defined ports for attributes will be reported, however
send A.nonExistingAttribute(int);
// mappings are not checked, here string would not match
diff --git a/ragconnect.tests/src/test/01-input/errors/Standard.expected b/ragconnect.tests/src/test/01-input/errors/Standard.expected
index 1f2b02da133cc26bc9660b466112cb73421ab529..c8ce47b509c4f84f1dc36d2465b0910d506cd5fc 100644
--- a/ragconnect.tests/src/test/01-input/errors/Standard.expected
+++ b/ragconnect.tests/src/test/01-input/errors/Standard.expected
@@ -1,15 +1,15 @@
-Standard.connect Line 3, column 1: Endpoint definition already defined for B.DoubledValue
-Standard.connect Line 4, column 1: Endpoint definition already defined for B.DoubledValue
+Standard.connect Line 3, column 1: Port definition already defined for B.DoubledValue
+Standard.connect Line 4, column 1: Port definition already defined for B.DoubledValue
Standard.connect Line 10, column 1: Receiving target token must not be an NTA token!
Standard.connect Line 13, column 1: No suitable default mapping found for type java.util.List<String>
Standard.connect Line 16, column 1: to-type of last mapping (java.util.List<String>) not assignable to type of the token (String)!
Standard.connect Line 19, column 1: to-type of last mapping (int) not assignable to type of the token (String)!
-Standard.connect Line 22, column 9: Context-Free endpoint not allowed for root node A!
-Standard.connect Line 26, column 1: Clash with implied, indexed endpoint definition of context-free endpoint in line 25!
-Standard.connect Line 30, column 9: Could not resolve endpoint target C.NonExisting
-Standard.connect Line 43, column 1: Endpoint definition already defined for C.DoubledValue
-Standard.connect Line 44, column 1: Endpoint definition already defined for C.DoubledValue
+Standard.connect Line 22, column 9: Context-Free port not allowed for root node A!
+Standard.connect Line 26, column 1: Clash with implied, indexed port definition of context-free port in line 25!
+Standard.connect Line 30, column 9: Could not resolve port target C.NonExisting
+Standard.connect Line 43, column 1: Port definition already defined for C.DoubledValue
+Standard.connect Line 44, column 1: Port definition already defined for C.DoubledValue
Standard.connect Line 55, column 1: The name of a dependency definition must not be equal to a list-node on the source
Standard.connect Line 60, column 1: Dependency definition already defined for D with name DoubledValue
-Standard.connect Line 64, column 1: Endpoint definition already defined for A.nonExistingAttribute
-Standard.connect Line 67, column 1: Endpoint definition already defined for A.nonExistingAttribute
+Standard.connect Line 64, column 1: Port definition already defined for A.nonExistingAttribute
+Standard.connect Line 67, column 1: Port definition already defined for A.nonExistingAttribute
diff --git a/ragconnect.tests/src/test/01-input/forwarding/README.md b/ragconnect.tests/src/test/01-input/forwarding/README.md
index 522815706491182dbd0766ee6b2e83e6a5e5d64a..9b12df3139ec9194bfab45996b823fd0578d1b12 100644
--- a/ragconnect.tests/src/test/01-input/forwarding/README.md
+++ b/ragconnect.tests/src/test/01-input/forwarding/README.md
@@ -1,6 +1,6 @@
# Forwarding
Idea: Use send definitions targeting only non-NTAs (thus, requiring the creation of implicit NTAs).
-Also test context-free endpoint definitions targeting non-NTAs to test compatibility of those two features.
+Also test context-free port definitions targeting non-NTAs to test compatibility of those two features.
-Note: When a type occurs in a list, the context-free endpoint definition will force an (implicit) indexed send for that context.
+Note: When a type occurs in a list, the context-free port definition will force an (implicit) indexed send for that context.
diff --git a/ragconnect.tests/src/test/01-input/incremental/Test.connect b/ragconnect.tests/src/test/01-input/incremental/Test.connect
index 8135be4e3afc9801b45d858ce9bda9016351e4a4..070f4e1b159a5537d263067d617a2cab22303fb9 100644
--- a/ragconnect.tests/src/test/01-input/incremental/Test.connect
+++ b/ragconnect.tests/src/test/01-input/incremental/Test.connect
@@ -1,4 +1,4 @@
-// endpoint definitions
+// port definitions
receive A.Input ;
send A.OutputOnA ;
send B.OutputOnB using Transformation ;
diff --git a/ragconnect.tests/src/test/01-input/tutorial/Test.connect b/ragconnect.tests/src/test/01-input/tutorial/Test.connect
index c6bdc7b3c4f5dcf661ce2ce757301e42eb39a1a7..f1f3af2d719924b5c5ddaccfd10771c5a2240c0f 100644
--- a/ragconnect.tests/src/test/01-input/tutorial/Test.connect
+++ b/ragconnect.tests/src/test/01-input/tutorial/Test.connect
@@ -1,4 +1,4 @@
-// endpoint definitions
+// port definitions
receive A.Input ;
send A.OutputOnA ;
send B.OutputOnB using Transformation ;
diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/singleListVariant/AbstractSingleListVariantTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/singleListVariant/AbstractSingleListVariantTest.java
index c01284592d2690c0722b233d89de80f6dae485c8..6bd40a7a5e8135aec0e2e2f45ed5e271fff1239c 100644
--- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/singleListVariant/AbstractSingleListVariantTest.java
+++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/singleListVariant/AbstractSingleListVariantTest.java
@@ -372,10 +372,10 @@ public abstract class AbstractSingleListVariantTest extends AbstractMqttTest {
* Check against expected lists of IDs.
* If an ID is negative, do not check Opts and Lists, but use absolute value for comparison.
* The tests starts with ID 0 and does not use opts and lists at this point, so checking with > 0 is used.
- * @param expectedList ids for unnamed and named endpoints without add
- * @param expectedWithAddList ids for endpoints with add, but not those with opts and lists
+ * @param expectedList ids for unnamed and named ports without add
+ * @param expectedWithAddList ids for ports with add, but not those with opts and lists
* (only positive numbers can/need to be passed)
- * @param expectedWithAddListForOptAndList ids for endpoints with add and with opts and lists
+ * @param expectedWithAddListForOptAndList ids for ports with add and with opts and lists
*/
private void checkTree(IntList expectedList,
IntList expectedWithAddList,
diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/tree/AbstractTreeTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/tree/AbstractTreeTest.java
index c8f87c184a555fc65006e30a023992812ee94295..9b2e18f5a5fd075843b4022386408c944506f0be 100644
--- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/tree/AbstractTreeTest.java
+++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/tree/AbstractTreeTest.java
@@ -16,6 +16,7 @@ import static org.junit.jupiter.api.Assertions.*;
* @author rschoene - Initial contribution
*/
@Tag("Tree")
+@Tag("New")
public abstract class AbstractTreeTest extends AbstractMqttTest {
protected static final String TOPIC_ALFA = "alfa";
protected ReceiverData data;