Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorHenrik Rentz-Reichert2018-12-22 16:00:39 -0500
committerHenrik Rentz-Reichert2019-01-18 12:54:29 -0500
commita6de841644187d23fb207b1ba1b0433e6348bec3 (patch)
tree4f14bff8841573acede4968f55c0fac278ad380f /plugins
parent71d8ecc0556364aec9c55ec0df9328f3197bd85e (diff)
downloadorg.eclipse.etrice-a6de841644187d23fb207b1ba1b0433e6348bec3.tar.gz
org.eclipse.etrice-a6de841644187d23fb207b1ba1b0433e6348bec3.tar.xz
org.eclipse.etrice-a6de841644187d23fb207b1ba1b0433e6348bec3.zip
WIP: [doc] completed feature model
Diffstat (limited to 'plugins')
-rw-r--r--plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer377
-rw-r--r--plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md704
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/contextHelp.xml205
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html128
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html126
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html681
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html36
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html14
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html31
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html21
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html2
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html11
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html33
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html3
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html9
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html11
-rw-r--r--plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html3
22 files changed, 2056 insertions, 354 deletions
diff --git a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
index 411359426..fe310d75e 100644
--- a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
+++ b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
@@ -26,8 +26,8 @@ Package ROOMLanguage
Feature AnnotationType
description '''AnnotationTypes can be used to tag ROOM classes for further custom processing'''
text '''
- They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.
- eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.
+ They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.
+ eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.
See section Annotations for further reading.
'''
@@ -44,7 +44,7 @@ stable
;
Feature Annotation
-description '''An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType'''
+description '''An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType'''
text '''
It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:
@@ -78,7 +78,7 @@ stable
;
Feature Inheritance
- description '''A class can specify a super class and inherits elements from the super class hierarchy'''
+ description '''A class can specify a single super class and inherits elements from the super class hierarchy'''
text '''
When a ROOM class specifies a super class, it generally inherits all elements and properties.
In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.
@@ -86,28 +86,28 @@ Feature Inheritance
In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.
Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.
- A formal definition of overriding is given below:
+ A formal definition of several variants of overriding is given below:
- - early or late resolve - if element is overridden, which one should super class use by default - own or override ?
- - replacing or refinement - ignore inherited code or prepend inherited code automatically ?
- - (non-)accessible - if element is overridden, is super class' original accessible from sub class ? e.g. super.foo()
- - implicit or explicit - does it use distinct model element / keyword?
+ - early or late resolve - if element is overridden, which one should the super class use by default - own or override?
+ - replacing or refining - ignore inherited code or prepend inherited code automatically?
+ - (non-)accessible - if element is overridden, is super class' original accessible from sub class? E.g. super.foo()
+ - implicit or explicit - does it use a distinct model element or keyword?
- Examples programming languages:
- c++ virtual function and java override <==> accessible explicit late replacing
- c++ function redefine <==> accessible implicit early replacing
- c++ dtor <==> late refinement\\
+ Examples from programming languages:
+ C++ virtual function and Java override <==> accessible, explicit, late, replacing
+ C++ function redefine <==> accessible, implicit, early, replacing
+ C++ destructor <==> late, refining\\
eTrice override of model elements:
- Operations (C generation) <==> non\_accessible explicit late replacing
- Operations (Java generation) <==> accessible explicit late replacing
- State and Transitions <==> non-accessible explicit late refinement
- ctor/dtor <==> non\_accessible implicit late refinement
- StateMachine <==> non-accessible implicit late refinement
- UserCode <==> non-accessible implicit late refinement
+ Operations (C generation) <==> non-accessible, explicit, late, replacing
+ Operations (Java generation) <==> accessible, explicit, late, replacing
+ State and Transitions <==> non-accessible, explicit, late, refining
+ ctor/dtor <==> non-accessible, implicit, late, refining
+ StateMachine <==> non-accessible, implicit, late, refining
+ UserCode <==> non-accessible, implicit, late, refining
'''
- example ¦¦¦
+ example |||
```room
ActorClass ActorSubClass extends ActorBaseClass {
// inherits all elements from super type hierarchy
@@ -145,7 +145,7 @@ Feature Inheritance
Attribute attribute1 : uint32
}
```
- ¦¦¦
+ |||
prototype
;
@@ -353,7 +353,7 @@ Feature ActorClass
'''
example ''''''
- help ¦¦¦
+ help |||
```room
// prefixes: abstract and (eventdriven, datadriven, async, sync)
ActorClass ActorName ["An eventdriven ActorClass by default"] {
@@ -382,7 +382,7 @@ Feature ActorClass
}
}
```
- ¦¦¦
+ |||
contains ExecutionType
contains ActorRef
@@ -430,7 +430,19 @@ Feature SubSystemClass
Feature StateMachine
description '''A StateMachine describes the state based, event driven behavior of an ActorClass'''
text '''
- In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+ In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will
+ be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+
+ ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.
+ This is possible to arbitrary depth.
+
+ A state graph consists of
+
+ * states
+ * transitions
+ * transition points
+ * choice points
+ * initial point
![PingPongReceiverFSM](images/300-PingPongReceiverFSM.png)
@@ -448,8 +460,297 @@ Feature StateMachine
```
'''
uses Inheritance
+ contains StateGraphNode
+ contains Transition
stable
- ;
+;
+
+abstract Feature StateGraphNode
+ description '''A StateGraphNode is an abstract node of the state graph'''
+ text '''
+ A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.
+ '''
+ uses Inheritance
+ stable
+;
+
+abstract Feature State
+ description '''A State can be a plain State or a RefinedState'''
+ text '''
+ A State can be a plain State or a RefinedState.
+ '''
+ uses Inheritance
+ isA StateGraphNode
+ stable
+;
+
+Feature SimpleState
+ description '''A State is a node in the state graph representation of the state machine'''
+ text '''
+ A State has optional 'entry' and 'exit' codes. The entry code is executed when the state is entered, the exit code is executed
+ when it is left. In the case of an data driven (also known as polled) state machine, there also is a 'do' action code.
+ The do code is executed for the active state in each polling cycle.
+ A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines
+ form a tree which is called a 'hierarchical state machine'.
+ A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.
+ '''
+ help keyword "State" |||
+ ```room
+ ActorClass Example {
+ //...
+ Behavior {
+ StateMachine {
+ Transition init: initial -> Standby
+ Transition tr0: Standby -> Running {
+ triggers {
+ <timeout: to>
+ }
+ }
+ Transition tr1: Running -> Stopped {
+ triggers {
+ <timeout: to>
+ }
+ }
+ State Standby {
+ entry '''
+ to.startTimeout(200*10);'''
+ }
+ State Running {
+ entry '''
+ controllers.start();
+ to.startTimeout(200*10);'''
+ }
+ State Stopped {
+ entry '''controllers.stop();'''
+ }
+ }
+ }
+ }
+ ```
+ |||
+ uses Inheritance
+ uses StateMachine
+ isA State
+ stable
+;
+
+Feature RefinedState
+ description '''A RefinedState refines a State of one of the Actor's base class state machines'''
+ text '''
+ A State can be a plain State or a RefinedState.
+ '''
+ help |||
+ ```room
+ RefinedState BaseState {
+ exit '''// this is derived exit code'''
+ subgraph {
+ // add a sub state machine
+ Transition init: initial -> state0 { }
+ State state0
+ }
+ }
+ ```
+ |||
+ uses Inheritance
+ uses StateMachine
+ isA State
+ stable
+;
+
+Feature ChoicePoint
+ description '''a choice point is the state machine counterpart of a conditional statement'''
+ text '''
+ A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.
+ One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken
+ if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint
+ are CPBranchTransitions which have a mandatory condition (keyword 'cond'). The evaluation order of the conditions
+ is not deterministic.
+ '''
+ help |||
+ ```room
+ StateMachine {
+ State state0
+ State state1
+ State state2
+ State state3
+ TransitionPoint tr4
+ ChoicePoint cp0
+ Transition init0: initial -> state0
+ Transition tr0: state0 -> state1 {
+ triggers {
+ <in1: p0>
+ }
+ }
+ Transition tr1: state1 -> cp cp0 {
+ triggers {
+ <in1: p0>
+ }
+ }
+ Transition tr2: cp cp0 -> state3
+ Transition tr3: cp cp0 -> state2 {
+ cond '''true'''
+ }
+ Transition tr5: my tr4 -> state0 {
+ triggers {
+ <in2: p0>
+ }
+ }
+ }
+ ```
+ |||
+ isA StateGraphNode
+ uses ContinuationTransition
+ stable
+;
+
+abstract Feature TrPoint
+ description '''a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint'''
+ text '''text'''
+ help |||a TrPoint is an abstract element|||
+ isA StateGraphNode
+ stable
+;
+
+Feature TransitionPoint
+ description '''a transition point is the starting point of transitions that trigger for any state of this state machine'''
+ text '''text'''
+ help |||
+ ```room
+ StateMachine {
+ TransitionPoint tp1
+ Transition tr1: my tp1 -> my tp1 {
+ triggers {
+ <msg: port>
+ }
+ }
+ }
+ ```
+ |||
+ isA TrPoint
+ stable
+;
+
+Feature EntryPoint
+ description '''an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect'''
+ text '''text'''
+ help |||
+ ```room
+ StateMachine {
+ State state0 {
+ subgraph {
+ State state0
+ EntryPoint ep0
+ ExitPoint ep1
+ Transition tr0: my ep0 -> state0
+ Transition tr1: state0 -> my ep1 {
+ triggers {
+ <in1: p0>
+ }
+ }
+ }
+ }
+ State state1
+ Transition init0: initial -> ep0 of state0
+ Transition tr0: ep1 of state0 -> state1
+ }
+ ```
+ |||
+ isA TrPoint
+ stable
+;
+
+Feature ExitPoint
+ description '''an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start'''
+ text '''text'''
+ help |||help|||
+ isA TrPoint
+ stable
+;
+
+Feature Transition
+ description '''A Transition is an edge in the state graph representation of the state machine'''
+ text '''
+ A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.
+ Transition points can only be targets of transitions originating from the same transition point.
+ The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.
+ '''
+ help |||
+ ```room
+ Transition init: initial -> Standby
+ Transition tr0: Standby -> Running {
+ triggers {
+ <timeout: to>
+ }
+ }
+ ```
+ |||
+ uses Inheritance
+ stable
+;
+
+Feature InitialTransition
+ description '''the initial transition is used to identify the initial state'''
+ text '''The initial transition connects the initial point to a state. There can be at most one initial transition
+ in a state machine. Under special circumstances the initial transition can be omitted.
+ '''
+ help |||Transition init: initial -> state0|||
+ isA Transition
+ stable
+;
+
+Feature GuardedTransition
+ description '''the guarded transition is used by data driven state machines to trigger state transitions'''
+ text '''In data driven state machines guarded transitions fire whenever the guard condition evaluates to true.
+ The evaluation is performed in each polling cycle.
+ '''
+ help |||
+ Transition tr: running -> running {
+ guard '''data_counter_finish.finish == true && data_finish_flag == false'''
+ action '''++counter;'''
+ }
+ |||
+ idea
+;
+
+Feature ContinuationTransition
+ description '''the continuation transition is a transition with just an optional action code'''
+ text '''A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point'''
+ help '''
+ State running {
+ subgraph {
+ EntryPoint ep0
+ State active
+ Transition tr0: my ep0 -> active
+ }
+ }
+ '''
+ isA Transition
+ idea
+;
+
+Feature CPBranchTransition
+ description '''a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true'''
+ text '''A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional
+ programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as
+ a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its
+ condition evaluates to true. No order of evaluations is guaranteed.
+ '''
+ help |||
+ Transition tr3: cp cp0 -> state1 {
+ cond '''0<=counter && counter<3'''
+ }
+ |||
+ isA Transition
+ idea
+;
+
+Feature TriggeredTransition
+ description '''a triggered transition is used in event driven state machines to trigger state transitions'''
+ text '''text'''
+ help |||help|||
+ isA Transition
+ stable
+;
Feature SubSystemRef
description '''A Sub System Reference is an instance of an SubSystemClass'''
@@ -746,7 +1047,7 @@ Feature ProtocolClass
}
```
'''
- help ¦¦¦
+ help |||
```room
// prefixes: (eventdriven, datadriven, sync)
ProtocolClass ProtocolName ["An eventdriven ProtocolClass by default"] {
@@ -774,7 +1075,7 @@ Feature ProtocolClass
// inherits all elements from super class
}
```
- ¦¦¦
+ |||
contains CommunicationType
contains Attribute
contains Operation
@@ -801,7 +1102,7 @@ Feature PrimitiveType
'''
help '''
```room
- // java
+ // Java
PrimitiveType boolean: ptBoolean -> boolean (Boolean) default "false"
PrimitiveType int16: ptInteger -> short (Short) default "0"
@@ -870,7 +1171,7 @@ Feature DataClass
}
```
'''
- example ¦¦¦
+ example |||
```room
DataClass SimpleDataClass {
Attribute attribute1: uint16
@@ -887,8 +1188,8 @@ Feature DataClass
'''
}
```
- ¦¦¦
- help ¦¦¦
+ |||
+ help |||
```room
DataClass DataClassName ["Documentation"] {
Attribute ... // nested DataClasses possible
@@ -902,7 +1203,7 @@ Feature DataClass
...
}
```
- ¦¦¦
+ |||
isA DataType
contains Attribute
contains Operation
@@ -912,7 +1213,7 @@ Feature DataClass
Feature ExternalType
description '''An ExternalType is used to make an target language type accessible in ROOM'''
- example ¦¦¦
+ example |||
```room
// Include is needed when used (e.g. in ActorClassWithExternalType)
ExternalType someStructType -> "struct FILE_HANDLE"
@@ -932,7 +1233,7 @@ Feature ExternalType
}
}
```
- ¦¦¦
+ |||
help '''
```room
ExternalType voidType -> "void" default "NULL"
@@ -1015,7 +1316,7 @@ Feature Operation
- 'override' keyword, replaces the logic of the inherited operation having the same signature
'''
- example ¦¦¦
+ example |||
```room
import room.basic.types.* from "../../../org.eclipse.etrice.modellib.c/model/Types.room"
@@ -1053,8 +1354,8 @@ Feature Operation
}
}
```
- ¦¦¦
- help ¦¦¦
+ |||
+ help |||
```room
Operation operationName() ["A void operation"] '''
user code here;
@@ -1070,7 +1371,7 @@ Feature Operation
// becomes effective in entire inheritance hierarchy
override Operation operationName(param: int32) : boolean ''' '''
```
- ¦¦¦
+ |||
uses DataType
property returnType values { "DataType" }
property arguments values { "name : DataType" }
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
index 6e4a804c4..0d23476ec 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
@@ -255,13 +255,13 @@ An ActorClass consists of three main parts:
<tr>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;">Uses:</td>
<td>[Inheritance](#inheritance)
</td>
- <td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
</tr>
</tbody>
</table>
@@ -418,7 +418,7 @@ Instance hierarchy of ActorRef Example (*System(System)* not shown in code snipp
### Annotation
-An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType
+An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType
It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:
@@ -513,8 +513,8 @@ ActorClass ComponentAbstraction {
### AnnotationType
AnnotationTypes can be used to tag ROOM classes for further custom processing
-They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.
-eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.
+They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.
+eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.
See section Annotations for further reading.
@@ -531,7 +531,7 @@ See section Annotations for further reading.
<td rowspan="1" style="white-space: nowrap;">Typecasts:</td>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
@@ -735,6 +735,73 @@ ActorClass ExampleActorClass {
---
+### CPBranchTransition
+a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true
+
+A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional
+ programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as
+ a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its
+ condition evaluates to true. No order of evaluations is guaranteed.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### ChoicePoint
+a choice point is the state machine counterpart of a conditional statement
+
+A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.
+One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken
+if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint
+are CPBranchTransitions which have a mandatory condition (keyword 'cond'). The evaluation order of the conditions
+is not deterministic.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[StateGraphNode](#stategraphnode)
+ </td>
+ <td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Uses:</td>
+ <td>[ContinuationTransition](#continuationtransition)
+ </td>
+ <td>the continuation transition is a transition with just an optional action code</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
### CommunicationType
The CommunicationType defines the communication semantics of a ProtocolClass
@@ -820,6 +887,48 @@ datadriven ProtocolClass DatadrivenProtocolClass {
---
+### ContinuationTransition
+the continuation transition is a transition with just an optional action code
+
+A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is used by:</td>
+ <td>[ChoicePoint](#choicepoint)
+ </td>
+ <td>a choice point is the state machine counterpart of a conditional statement</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
### DataClass
A DataClass is a composition of Attributes
@@ -860,13 +969,13 @@ DataClass TCPConnectionData {
<tr>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;">Uses:</td>
<td>[Inheritance](#inheritance)
</td>
- <td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
</tr>
</tbody>
</table>
@@ -953,6 +1062,33 @@ A DataType can take 4 forms and types data elements like an Attribute or Operati
---
+### EntryPoint
+an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[TrPoint](#trpoint)
+ </td>
+ <td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
### Enumeration
An EnumerationType declares an enumeration similar to most well-known languages
@@ -1100,6 +1236,33 @@ async ActorClass MixedActor{
---
+### ExitPoint
+an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[TrPoint](#trpoint)
+ </td>
+ <td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
### ExternalEndPort
A ExternalEndPort is an interface Port, that is made accessible to the internal interface of an ActorClass
@@ -1202,7 +1365,7 @@ ActorClass ActorClassWithExternalType{
### Inheritance
-A class can specify a super class and inherits elements from the super class hierarchy
+A class can specify a single super class and inherits elements from the super class hierarchy
When a ROOM class specifies a super class, it generally inherits all elements and properties.
In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.
@@ -1210,26 +1373,26 @@ Refinement is used in most cases (e.g. StateMachine) and realizes an extension o
In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.
Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.
-A formal definition of overriding is given below:
+A formal definition of several variants of overriding is given below:
-- early or late resolve - if element is overridden, which one should super class use by default - own or override ?
-- replacing or refinement - ignore inherited code or prepend inherited code automatically ?
-- (non-)accessible - if element is overridden, is super class' original accessible from sub class ? e.g. super.foo()
-- implicit or explicit - does it use distinct model element / keyword?
+- early or late resolve - if element is overridden, which one should the super class use by default - own or override?
+- replacing or refining - ignore inherited code or prepend inherited code automatically?
+- (non-)accessible - if element is overridden, is super class' original accessible from sub class? E.g. super.foo()
+- implicit or explicit - does it use a distinct model element or keyword?
-Examples programming languages:
-c++ virtual function and java override <==> accessible explicit late replacing
-c++ function redefine <==> accessible implicit early replacing
-c++ dtor <==> late refinement\\
+Examples from programming languages:
+C++ virtual function and Java override <==> accessible, explicit, late, replacing
+C++ function redefine <==> accessible, implicit, early, replacing
+C++ destructor <==> late, refining\\
eTrice override of model elements:
-Operations (C generation) <==> non\_accessible explicit late replacing
-Operations (Java generation) <==> accessible explicit late replacing
-State and Transitions <==> non-accessible explicit late refinement
-ctor/dtor <==> non\_accessible implicit late refinement
-StateMachine <==> non-accessible implicit late refinement
-UserCode <==> non-accessible implicit late refinement
+Operations (C generation) <==> non-accessible, explicit, late, replacing
+Operations (Java generation) <==> accessible, explicit, late, replacing
+State and Transitions <==> non-accessible, explicit, late, refining
+ctor/dtor <==> non-accessible, implicit, late, refining
+StateMachine <==> non-accessible, implicit, late, refining
+UserCode <==> non-accessible, implicit, late, refining
@@ -1241,7 +1404,7 @@ UserCode <==> non-accessible implicit late refinement
</thead>
<tbody>
<tr>
- <td rowspan="4" style="white-space: nowrap;">Is used by:</td>
+ <td rowspan="9" style="white-space: nowrap;">Is used by:</td>
<td>[ActorClass](#actorclass)
</td>
<td>An actor is the basic structural building block for building systems with ROOM</td>
@@ -1252,6 +1415,31 @@ UserCode <==> non-accessible implicit late refinement
<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
</tr>
<tr>
+ <td>[StateGraphNode](#stategraphnode)
+ </td>
+ <td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+ <td>[State](#state)
+ </td>
+ <td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+ <td>[SimpleState](#simplestate)
+ </td>
+ <td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+ <td>[RefinedState](#refinedstate)
+ </td>
+ <td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
+<tr>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+<tr>
<td>[ProtocolClass](#protocolclass)
</td>
<td>A ProtocolClass defines messages and is the interface specification for a Port</td>
@@ -1307,6 +1495,34 @@ DataClass DataBaseClass {
---
+### InitialTransition
+the initial transition is used to identify the initial state
+
+The initial transition connects the initial point to a state. There can be at most one initial transition
+ in a state machine. Under special circumstances the initial transition can be omitted.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
### InternalEndPort
A InternalEndPort is an local Port, that is declared in the internal interface of an ActorClass
@@ -1433,7 +1649,7 @@ It describes the logical topology of your distributed system and is composed of
<tr>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
</tbody>
</table>
@@ -1800,13 +2016,13 @@ ProtocolClass SimpleProtocolClass {
<tr>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;">Uses:</td>
<td>[Inheritance](#inheritance)
</td>
- <td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
</tr>
</tbody>
</table>
@@ -1886,6 +2102,44 @@ datadriven ProtocolClass ProtocolClassData {
---
+### RefinedState
+A RefinedState refines a State of one of the Actor's base class state machines
+
+A State can be a plain State or a RefinedState.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[State](#state)
+ </td>
+ <td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;">Uses:</td>
+ <td>[Inheritance](#inheritance)
+ </td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+<tr>
+ <td>[StateMachine](#statemachine)
+ </td>
+ <td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
### RelayPort
A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass
@@ -2135,10 +2389,176 @@ The implementation of an Service Provision Point (SPP)
---
+### SimpleState
+A State is a node in the state graph representation of the state machine
+
+A State has optional 'entry' and 'exit' codes. The entry code is executed when the state is entered, the exit code is executed
+when it is left. In the case of an data driven (also known as polled) state machine, there also is a 'do' action code.
+The do code is executed for the active state in each polling cycle.
+A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines
+form a tree which is called a 'hierarchical state machine'.
+A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[State](#state)
+ </td>
+ <td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;">Uses:</td>
+ <td>[Inheritance](#inheritance)
+ </td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+<tr>
+ <td>[StateMachine](#statemachine)
+ </td>
+ <td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### State
+A State can be a plain State or a RefinedState
+
+A State can be a plain State or a RefinedState.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[StateGraphNode](#stategraphnode)
+ </td>
+ <td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Uses:</td>
+ <td>[Inheritance](#inheritance)
+ </td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;">Inheriting features:</td>
+ <td>[SimpleState](#simplestate)
+ </td>
+ <td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+ <td>[RefinedState](#refinedstate)
+ </td>
+ <td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### StateGraphNode
+A StateGraphNode is an abstract node of the state graph
+
+A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Uses:</td>
+ <td>[Inheritance](#inheritance)
+ </td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="3" style="white-space: nowrap;">Inheriting features:</td>
+ <td>[State](#state)
+ </td>
+ <td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+ <td>[ChoicePoint](#choicepoint)
+ </td>
+ <td>a choice point is the state machine counterpart of a conditional statement</td>
+</tr>
+<tr>
+ <td>[TrPoint](#trpoint)
+ </td>
+ <td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
+ <td>[StateMachine](#statemachine)
+ </td>
+ <td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
### StateMachine
A StateMachine describes the state based, event driven behavior of an ActorClass
-In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will
+be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+
+ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.
+This is possible to arbitrary depth.
+
+A state graph consists of
+
+* states
+* transitions
+* transition points
+* choice points
+* initial point
![PingPongReceiverFSM](images/300-PingPongReceiverFSM.png)
@@ -2152,10 +2572,21 @@ In ROOM each actor class can implement its behavior using a state machine. Event
</thead>
<tbody>
<tr>
+ <td rowspan="2" style="white-space: nowrap;">Contains:</td>
+ <td>[StateGraphNode](#stategraphnode)
+ </td>
+ <td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+<tr>
<td rowspan="1" style="white-space: nowrap;">Uses:</td>
<td>[Inheritance](#inheritance)
</td>
- <td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
</tr>
</tbody>
</table>
@@ -2179,6 +2610,17 @@ In ROOM each actor class can implement its behavior using a state machine. Event
</td>
<td>The GraphicalBehaviorEditor allows to edit the ActorClass' StateMachine. It is possible to create (hierarchical) states and transitions to model complex behavior in a convenient way.</td>
</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;">Is used by:</td>
+ <td>[SimpleState](#simplestate)
+ </td>
+ <td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+ <td>[RefinedState](#refinedstate)
+ </td>
+ <td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
</tbody>
</table>
@@ -2219,7 +2661,7 @@ A SubSystemClass is the structural starting point of an ROOM application. Thus i
<tr>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
</tbody>
</table>
@@ -2302,6 +2744,177 @@ A physical node is denoted by a NodeClass and NodeRef in the PhysicalModel. The
---
+### TrPoint
+a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[StateGraphNode](#stategraphnode)
+ </td>
+ <td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="3" style="white-space: nowrap;">Inheriting features:</td>
+ <td>[TransitionPoint](#transitionpoint)
+ </td>
+ <td>a transition point is the starting point of transitions that trigger for any state of this state machine</td>
+</tr>
+<tr>
+ <td>[EntryPoint](#entrypoint)
+ </td>
+ <td>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</td>
+</tr>
+<tr>
+ <td>[ExitPoint](#exitpoint)
+ </td>
+ <td>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### Transition
+A Transition is an edge in the state graph representation of the state machine
+
+A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.
+Transition points can only be targets of transitions originating from the same transition point.
+The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Uses:</td>
+ <td>[Inheritance](#inheritance)
+ </td>
+ <td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="4" style="white-space: nowrap;">Inheriting features:</td>
+ <td>[InitialTransition](#initialtransition)
+ </td>
+ <td>the initial transition is used to identify the initial state</td>
+</tr>
+<tr>
+ <td>[ContinuationTransition](#continuationtransition)
+ </td>
+ <td>the continuation transition is a transition with just an optional action code</td>
+</tr>
+<tr>
+ <td>[CPBranchTransition](#cpbranchtransition)
+ </td>
+ <td>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</td>
+</tr>
+<tr>
+ <td>[TriggeredTransition](#triggeredtransition)
+ </td>
+ <td>a triggered transition is used in event driven state machines to trigger state transitions</td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
+ <td>[StateMachine](#statemachine)
+ </td>
+ <td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### TransitionPoint
+a transition point is the starting point of transitions that trigger for any state of this state machine
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[TrPoint](#trpoint)
+ </td>
+ <td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### TriggeredTransition
+a triggered transition is used in event driven state machines to trigger state transitions
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;">Is a:</td>
+ <td>[Transition](#transition)
+ </td>
+ <td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
## MappingModel
The MappingModel describes the mapping of elements of the LogicalModel to elements of the PhysicalModel
@@ -2916,7 +3529,7 @@ The built-in **Gnuplot script generator** provides a convenient way to visualize
<td rowspan="1" style="white-space: nowrap;">Uses:</td>
<td>[Annotation](#annotation)
</td>
- <td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+ <td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
</tr>
</tbody>
</table>
@@ -3117,6 +3730,12 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
[ActorRefPropertyDialog]: #actorrefpropertydialog
[PortPropertyDialog]: #portpropertydialog
[SPPPropertyDialog]: #spppropertydialog
+[CCodeGenerator]: #ccodegenerator
+[JavaCodeGenerator]: #javacodegenerator
+[CPPCodeGenerator]: #cppcodegenerator
+[GenerationOptions]: #generationoptions
+[MSCLogging]: #msclogging
+[DataLogging]: #datalogging
[AnnotationType]: #annotationtype
[Annotation]: #annotation
[Inheritance]: #inheritance
@@ -3128,6 +3747,21 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
[ActorClass]: #actorclass
[SubSystemClass]: #subsystemclass
[StateMachine]: #statemachine
+[StateGraphNode]: #stategraphnode
+[State]: #state
+[SimpleState]: #simplestate
+[RefinedState]: #refinedstate
+[ChoicePoint]: #choicepoint
+[TrPoint]: #trpoint
+[TransitionPoint]: #transitionpoint
+[EntryPoint]: #entrypoint
+[ExitPoint]: #exitpoint
+[Transition]: #transition
+[InitialTransition]: #initialtransition
+[GuardedTransition]: #guardedtransition
+[ContinuationTransition]: #continuationtransition
+[CPBranchTransition]: #cpbranchtransition
+[TriggeredTransition]: #triggeredtransition
[SubSystemRef]: #subsystemref
[Replication]: #replication
[ActorRef]: #actorref
@@ -3150,9 +3784,3 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
[SAP]: #sap
[ServiceImplementation]: #serviceimplementation
[SPP]: #spp
-[CCodeGenerator]: #ccodegenerator
-[JavaCodeGenerator]: #javacodegenerator
-[CPPCodeGenerator]: #cppcodegenerator
-[GenerationOptions]: #generationoptions
-[MSCLogging]: #msclogging
-[DataLogging]: #datalogging
diff --git a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
index ad2eb274b..d106a8eea 100644
--- a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
+++ b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
@@ -57,6 +57,44 @@
<topic href="targets/eclipse-help/feature-reference.html#spppropertydialog" label="GraphicalStructureEditor"/>
</context>
+<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
+<description>Mechanism to adjust the generation.</description>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
+</context>
+
+<context id="featureContextHelp_MSCLogging" title="MSCLogging">
+<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_DataLogging" title="DataLogging">
+<description>Runtime logger for data-driven Messages with primitive data.</description>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
+</context>
+
<context id="featureContextHelp_AnnotationType" title="AnnotationType">
<description>AnnotationTypes can be used to tag ROOM classes for further custom processing</description>
<topic href="targets/eclipse-help/feature-reference.html#annotationtype" label="AnnotationType"/>
@@ -65,22 +103,27 @@
</context>
<context id="featureContextHelp_Annotation" title="Annotation">
-<description>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</description>
+<description>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</description>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="Annotation"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="AnnotationType"/>
+<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="LogicalSystem"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="ActorClass"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="SubSystemClass"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="ProtocolClass"/>
<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
</context>
<context id="featureContextHelp_Inheritance" title="Inheritance">
-<description>A class can specify a super class and inherits elements from the super class hierarchy</description>
+<description>A class can specify a single super class and inherits elements from the super class hierarchy</description>
<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Inheritance"/>
<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="ActorClass"/>
<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="StateGraphNode"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="RefinedState"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Transition"/>
<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="ProtocolClass"/>
<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="DataClass"/>
</context>
@@ -139,6 +182,90 @@
<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="Inheritance"/>
<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="GraphicalBehaviorEditor"/>
<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="ActorClass"/>
+<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="RefinedState"/>
+</context>
+
+<context id="featureContextHelp_State" title="State">
+<description>A State is a node in the state graph representation of the state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="State"/>
+</context>
+
+<context id="featureContextHelp_RefinedState" title="RefinedState">
+<description>A RefinedState refines a State of one of the Actor's base class state machines</description>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="RefinedState"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="State"/>
+</context>
+
+<context id="featureContextHelp_ChoicePoint" title="ChoicePoint">
+<description>a choice point is the state machine counterpart of a conditional statement</description>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ChoicePoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="StateGraphNode"/>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ContinuationTransition"/>
+</context>
+
+<context id="featureContextHelp_TransitionPoint" title="TransitionPoint">
+<description>a transition point is the starting point of transitions that trigger for any state of this state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TransitionPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_EntryPoint" title="EntryPoint">
+<description>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</description>
+<topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="EntryPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_ExitPoint" title="ExitPoint">
+<description>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</description>
+<topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="ExitPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_Transition" title="Transition">
+<description>A Transition is an edge in the state graph representation of the state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="Transition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="InitialTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="ContinuationTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="CPBranchTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="TriggeredTransition"/>
+</context>
+
+<context id="featureContextHelp_InitialTransition" title="InitialTransition">
+<description>the initial transition is used to identify the initial state</description>
+<topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="InitialTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="Transition"/>
+</context>
+
+<context id="featureContextHelp_GuardedTransition" title="GuardedTransition">
+<description>the guarded transition is used by data driven state machines to trigger state transitions</description>
+<topic href="targets/eclipse-help/feature-reference.html#guardedtransition" label="GuardedTransition"/>
+</context>
+
+<context id="featureContextHelp_ContinuationTransition" title="ContinuationTransition">
+<description>the continuation transition is a transition with just an optional action code</description>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ContinuationTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="Transition"/>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ChoicePoint"/>
+</context>
+
+<context id="featureContextHelp_CPBranchTransition" title="CPBranchTransition">
+<description>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</description>
+<topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="CPBranchTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="Transition"/>
+</context>
+
+<context id="featureContextHelp_TriggeredTransition" title="TriggeredTransition">
+<description>a triggered transition is used in event driven state machines to trigger state transitions</description>
+<topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="TriggeredTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="Transition"/>
</context>
<context id="featureContextHelp_SubSystemRef" title="SubSystemRef">
@@ -149,13 +276,6 @@
<topic href="targets/eclipse-help/feature-reference.html#subsystemref" label="LogicalSystem"/>
</context>
-<context id="featureContextHelp_Replication" title="Replication">
-<description>Replication is mechanism for multi-instantiation for ActorRefs and Ports</description>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="Replication"/>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="ActorRef"/>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="Port"/>
-</context>
-
<context id="featureContextHelp_ActorRef" title="ActorRef">
<description>An ActorRef is an instance of an ActorClass</description>
<topic href="targets/eclipse-help/feature-reference.html#actorref" label="ActorRef"/>
@@ -211,18 +331,6 @@
<topic href="targets/eclipse-help/feature-reference.html#protocolclass" label="SPP"/>
</context>
-<context id="featureContextHelp_DataType" title="DataType">
-<description>A DataType can take 4 forms and types data elements like an Attribute or Operation argument</description>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="LogicalModel"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="PrimitiveType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Enumeration"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="ExternalType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Attribute"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Operation"/>
-</context>
-
<context id="featureContextHelp_PrimitiveType" title="PrimitiveType">
<description>A PrimitiveType is an abstraction of a target language's basic type (e.g. integer or boolean)</description>
<topic href="targets/eclipse-help/feature-reference.html#primitivetype" label="PrimitiveType"/>
@@ -267,21 +375,6 @@
<topic href="targets/eclipse-help/feature-reference.html#operation" label="DataClass"/>
</context>
-<context id="featureContextHelp_Port" title="Port">
-<description>A Port is an instance of a ProtocolClass and the interface for an ActorClass</description>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Port"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ProtocolClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Replication"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="GraphicalStructureEditor"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="PortPropertyDialog"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ActorClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Binding"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Binding"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="RelayPort"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ExternalEndPort"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="InternalEndPort"/>
-</context>
-
<context id="featureContextHelp_RelayPort" title="RelayPort">
<description>A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass</description>
<topic href="targets/eclipse-help/feature-reference.html#relayport" label="RelayPort"/>
@@ -325,42 +418,4 @@
<topic href="targets/eclipse-help/feature-reference.html#spp" label="LayerConnection"/>
<topic href="targets/eclipse-help/feature-reference.html#spp" label="ServiceImplementation"/>
</context>
-
-<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
-<description>Mechanism to adjust the generation.</description>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
-</context>
-
-<context id="featureContextHelp_MSCLogging" title="MSCLogging">
-<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_DataLogging" title="DataLogging">
-<description>Runtime logger for data-driven Messages with primitive data.</description>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
-</context>
</contexts>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
index 3c17cae69..b04dbbfe5 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
@@ -96,9 +96,9 @@
<p>Open <em>BlinkyTutorial.room</em> and create a new Actor called AHWAbstraction by adding the following text:</p>
<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> AHWAbstraction {
<span class="keyword">Structure</span> {
- <span class="keyword">usercode1</span> '''
- #include <span class="string">"Dave.h"</span>
- '''
+ <span class="keyword">usercode1</span> <span class="string">'''
+ #include "Dave.h"
+ '''</span>
}
}
</code></pre>
@@ -130,9 +130,9 @@
<span class="keyword">Port</span> LED1: POnOff
}
<span class="keyword">Structure</span> {
- <span class="keyword">usercode1</span> '''
- #include <span class="string">"Dave.h"</span>
- '''
+ <span class="keyword">usercode1</span> <span class="string">'''
+ #include "Dave.h"
+ '''</span>
<span class="keyword">external</span> <span class="keyword">Port</span> LED1
}
<span class="keyword">Behavior</span> {
@@ -143,17 +143,17 @@
<span class="keyword">triggers</span> {
&lt;on: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;off: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
- '''
+ '''</span>
}
}
}
@@ -186,25 +186,25 @@
<span class="keyword">State</span> state0
<span class="keyword">State</span> state1
<span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
timer.startTimer(300);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr0: state0 -&gt; state1 {
<span class="keyword">triggers</span> {
&lt;timeout: timer&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.on();
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: state1 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;timeout: timer&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.off();
- '''
+ '''</span>
}
}
}
@@ -243,25 +243,25 @@
<span class="keyword">State</span> state0
<span class="keyword">State</span> state1
<span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
timer.startTimer(300);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr0: state0 -&gt; state1 {
<span class="keyword">triggers</span> {
&lt;timeout: timer&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.on();
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: state1 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;timeout: timer&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.off();
- '''
+ '''</span>
}
}
}
@@ -272,9 +272,9 @@
<span class="keyword">Port</span> LED1: POnOff
}
<span class="keyword">Structure</span> {
- <span class="keyword">usercode1</span> '''
- #include <span class="string">"Dave.h"</span>
- '''
+ <span class="keyword">usercode1</span> <span class="string">'''
+ #include "Dave.h"
+ '''</span>
<span class="keyword">external</span> <span class="keyword">Port</span> LED1
}
<span class="keyword">Behavior</span> {
@@ -285,17 +285,17 @@
<span class="keyword">triggers</span> {
&lt;on: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;off: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
- '''
+ '''</span>
}
}
}
@@ -378,14 +378,14 @@
<span class="keyword">State</span> blinking {
<span class="keyword">subgraph</span> {
<span class="keyword">State</span> on {
- <span class="keyword">entry</span> '''
+ <span class="keyword">entry</span> <span class="string">'''
out.on();
- '''
+ '''</span>
}
<span class="keyword">State</span> off {
- <span class="keyword">entry</span> '''
+ <span class="keyword">entry</span> <span class="string">'''
out.off();
- '''
+ '''</span>
}
<span class="keyword">EntryPoint</span> tp0
<span class="keyword">Transition</span> tr0: on -&gt; off {
@@ -399,9 +399,9 @@
}
}
<span class="keyword">Transition</span> tr2: <span class="keyword">my</span> tp0 -&gt; on {
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
timer.startTimer(300);
- '''
+ '''</span>
}
}
}
@@ -417,10 +417,10 @@
<span class="keyword">triggers</span> {
&lt;off: ctrl&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
timer.kill();
out.off();
- '''
+ '''</span>
}
}
}
@@ -434,9 +434,9 @@
<span class="keyword">conjugated</span> <span class="keyword">Port</span> BUTTON2: POnOff
}
<span class="keyword">Structure</span> {
- <span class="keyword">usercode1</span> '''
- #include <span class="string">"Dave.h"</span>
- '''
+ <span class="keyword">usercode1</span> <span class="string">'''
+ #include "Dave.h"
+ '''</span>
<span class="keyword">SAP</span> timer: PTimer
<span class="keyword">external</span> <span class="keyword">Port</span> LED1
<span class="keyword">external</span> <span class="keyword">Port</span> LED2
@@ -449,77 +449,77 @@
<span class="keyword">StateMachine</span> {
<span class="keyword">State</span> state0
<span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
timer.startTimer(50);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr0: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;on: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;off: LED1&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr2: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;on: LED2&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputHigh(&amp;LED2_P5_8);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr3: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;off: LED2&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
DIGITAL_IO_SetOutputLow(&amp;LED2_P5_8);
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr4: state0 -&gt; state0 {
<span class="keyword">triggers</span> {
&lt;timeout: timer&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
if (DIGITAL_IO_GetInput(&amp;BUTTON1_P15_13) == 0) {
if (b1Status == 0) {
- <span class="comment">// input changed
-</span> b1Status = 1;
+ // input changed
+ b1Status = 1;
BUTTON1.on();
}
}
else {
if (b1Status == 1) {
- <span class="comment">// input changed
-</span> b1Status = 0;
+ // input changed
+ b1Status = 0;
BUTTON1.off();
}
}
if (DIGITAL_IO_GetInput(&amp;BUTTON2_P15_12) == 0) {
if (b2Status == 0){
- <span class="comment">// input changed
-</span> b2Status = 1;
+ // input changed
+ b2Status = 1;
BUTTON2.on();
}
}
else {
if (b2Status == 1) {
- <span class="comment">// input changed
-</span> b2Status = 0;
+ // input changed
+ b2Status = 0;
BUTTON2.off();
}
}
- '''
+ '''</span>
}
}
}
@@ -550,17 +550,17 @@
<span class="keyword">triggers</span> {
&lt;on: ctrl&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.on();
- '''
+ '''</span>
}
<span class="keyword">Transition</span> tr1: on -&gt; off {
<span class="keyword">triggers</span> {
&lt;on: ctrl&gt;
}
- <span class="keyword">action</span> '''
+ <span class="keyword">action</span> <span class="string">'''
out.off();
- '''
+ '''</span>
}
}
}
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
index f9d3225d4..29f4204a4 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
@@ -743,6 +743,24 @@
+<li><a href="feature-reference.html#cpbranchtransition">CPBranchTransition</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#choicepoint">ChoicePoint</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#communicationtype">CommunicationType</a></li>
@@ -752,6 +770,15 @@
+<li><a href="feature-reference.html#continuationtransition">ContinuationTransition</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#dataclass">DataClass</a></li>
@@ -770,6 +797,15 @@
+<li><a href="feature-reference.html#entrypoint">EntryPoint</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#enumeration">Enumeration</a></li>
@@ -788,6 +824,15 @@
+<li><a href="feature-reference.html#exitpoint">ExitPoint</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#externalendport">ExternalEndPort</a></li>
@@ -815,6 +860,15 @@
+<li><a href="feature-reference.html#initialtransition">InitialTransition</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#internalendport">InternalEndPort</a></li>
@@ -878,6 +932,15 @@
+<li><a href="feature-reference.html#refinedstate">RefinedState</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#relayport">RelayPort</a></li>
@@ -923,6 +986,33 @@
+<li><a href="feature-reference.html#simplestate">SimpleState</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#state">State</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#stategraphnode">StateGraphNode</a></li>
+
+
+
+
+
+
+
+
<li><a href="feature-reference.html#statemachine">StateMachine</a></li>
@@ -950,6 +1040,42 @@
+<li><a href="feature-reference.html#trpoint">TrPoint</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#transition">Transition</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#transitionpoint">TransitionPoint</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#triggeredtransition">TriggeredTransition</a></li>
+
+
+
+
+
+
+
+
</ul>
</li>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
index 57997975a..0aa8fab51 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
@@ -210,12 +210,12 @@
</tr>
<tr>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
<td><p><a href="#inheritance">Inheritance</a></p></td>
- <td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
</tr>
</tbody>
</table>
@@ -347,7 +347,7 @@
<p>Instance hierarchy of ActorRef Example (*System(System)* not shown in code snippet)</p>
<hr>
<h3><a href="#annotation" name="annotation"></a>Annotation</h3>
-<p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p>
+<p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p>
<p>It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:</p>
<pre><code class="room customHighlighted">@AnnotationType1
@AnnotationType2(key1=<span class="string">"STRING"</span>, key2=3, ...)
@@ -421,7 +421,7 @@
<hr>
<h3><a href="#annotationtype" name="annotationtype"></a>AnnotationType</h3>
<p>AnnotationTypes can be used to tag ROOM classes for further custom processing</p>
-<p>They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.<br>eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.</p>
+<p>They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.<br>eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.</p>
<p>See section Annotations for further reading.</p>
<table style="vertical-align: middle;" class="table">
<thead>
@@ -433,7 +433,7 @@
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Typecasts:</p></td>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
@@ -600,6 +600,47 @@
</tbody>
</table>
<hr>
+<h3><a href="#cpbranchtransition" name="cpbranchtransition"></a>CPBranchTransition</h3>
+<p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p>
+<p>A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional<br> programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as<br> a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its<br> condition evaluates to true. No order of evaluations is guaranteed.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#choicepoint" name="choicepoint"></a>ChoicePoint</h3>
+<p>a choice point is the state machine counterpart of a conditional statement</p>
+<p>A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.<br>One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken<br>if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint<br>are CPBranchTransitions which have a mandatory condition (keyword ‘cond’). The evaluation order of the conditions<br>is not deterministic.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+ <td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#continuationtransition">ContinuationTransition</a></p></td>
+ <td><p>the continuation transition is a transition with just an optional action code</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#communicationtype" name="communicationtype"></a>CommunicationType</h3>
<p>The CommunicationType defines the communication semantics of a ProtocolClass</p>
<p>Since from ROOM models executable code can be generated, it is important to define the way the actors are executed and communicate with each other.<br>The combination of communication and execution is called the <em>execution model</em>. Therefore the ExecutionType of an actor and the CommunicationType of the ports has to be considered.</p>
@@ -671,6 +712,38 @@
</span><span class="comment">// }
</span></code></pre>
<hr>
+<h3><a href="#continuationtransition" name="continuationtransition"></a>ContinuationTransition</h3>
+<p>the continuation transition is a transition with just an optional action code</p>
+<p>A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is used by:</p></td>
+ <td><p><a href="#choicepoint">ChoicePoint</a></p></td>
+ <td><p>a choice point is the state machine counterpart of a conditional statement</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#dataclass" name="dataclass"></a>DataClass</h3>
<p>A DataClass is a composition of Attributes</p>
<p>Intended to model a type that primarily consists of data, which is usually grouped together in some manner. DataClasses roughly translate to Java classes without interaction or C <em>struct</em>s.</p>
@@ -702,30 +775,32 @@
</tr>
<tr>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
<td><p><a href="#inheritance">Inheritance</a></p></td>
- <td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
</tr>
</tbody>
</table>
<p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; DataClass SimpleDataClass {&lt;br/&gt; Attribute attribute1: uint16&lt;br/&gt; Attribute attribute2: uint32&lt;br/&gt; }&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt; DataClass DataClassExample {
- Attribute attribute1: uint32
- Attribute attribute2: SimpleDataClass
- Attribute attribute3: voidType ref
-
- Operation operation1(param1: uint32, param2: uint16): boolean &amp;#39;&amp;#39;&amp;#39;
- return true;
- &amp;#39;&amp;#39;&amp;#39;
- }
- ```
-¦¦¦
+<pre><code class="room customHighlighted"><span class="keyword">DataClass</span> SimpleDataClass {
+ <span class="keyword">Attribute</span> attribute1: uint16
+ <span class="keyword">Attribute</span> attribute2: uint32
+}
-</p><hr>
+<span class="keyword">DataClass</span> DataClassExample {
+ <span class="keyword">Attribute</span> attribute1: uint32
+ <span class="keyword">Attribute</span> attribute2: SimpleDataClass
+ <span class="keyword">Attribute</span> attribute3: voidType <span class="keyword">ref</span>
+
+ <span class="keyword">Operation</span> operation1(param1: uint32, param2: uint16): boolean <span class="string">'''
+ return true;
+ '''</span>
+}
+</code></pre>
+<hr>
<h3><a href="#datatype" name="datatype"></a>DataType</h3>
<p>A DataType can take 4 forms and types data elements like an Attribute or Operation argument</p>
<table style="vertical-align: middle;" class="table">
@@ -770,6 +845,24 @@
</tbody>
</table>
<hr>
+<h3><a href="#entrypoint" name="entrypoint"></a>EntryPoint</h3>
+<p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#trpoint">TrPoint</a></p></td>
+ <td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#enumeration" name="enumeration"></a>Enumeration</h3>
<p>An EnumerationType declares an enumeration similar to most well-known languages</p>
<table style="vertical-align: middle;" class="table">
@@ -887,6 +980,24 @@
</span>}
</code></pre>
<hr>
+<h3><a href="#exitpoint" name="exitpoint"></a>ExitPoint</h3>
+<p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#trpoint">TrPoint</a></p></td>
+ <td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#externalendport" name="externalendport"></a>ExternalEndPort</h3>
<p>A ExternalEndPort is an interface Port, that is made accessible to the internal interface of an ActorClass</p>
<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ExternalEndPortExample {
@@ -948,37 +1059,37 @@
</tbody>
</table>
<p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; // Include is needed when used (e.g. in ActorClassWithExternalType)&lt;br/&gt; ExternalType someStructType -&amp;gt; &amp;ldquo;struct FILE_HANDLE&amp;rdquo;&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt; ActorClass ActorClassWithExternalType{
- Structure {
- usercode1 &amp;#39;&amp;#39;&amp;#39;
- // #include &amp;lt;___.h&amp;gt; /* User includes here*/
- &amp;#39;&amp;#39;&amp;#39;
- Attribute someHandle : someStructType ref // needs include
- }
- Behavior {
- Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
- // external calls or casts may need includes
- write(someHandle, param1);
- &amp;#39;&amp;#39;&amp;#39;
- }
- }
- ```
-¦¦¦
+<pre><code class="room customHighlighted"><span class="comment">// Include is needed when used (e.g. in ActorClassWithExternalType)
+</span><span class="keyword">ExternalType</span> someStructType -&gt; <span class="string">"struct FILE_HANDLE"</span>
-</p><hr>
+<span class="keyword">ActorClass</span> ActorClassWithExternalType{
+ <span class="keyword">Structure</span> {
+ <span class="keyword">usercode1</span> <span class="string">'''
+ // #include &lt;___.h&gt; /* User includes here*/
+ '''</span>
+ <span class="keyword">Attribute</span> someHandle : someStructType <span class="keyword">ref</span> <span class="comment">// needs include
+</span> }
+ <span class="keyword">Behavior</span> {
+ <span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
+ // external calls or casts may need includes
+ write(someHandle, param1);
+ '''</span>
+ }
+}
+</code></pre>
+<hr>
<h3><a href="#inheritance" name="inheritance"></a>Inheritance</h3>
-<p>A class can specify a super class and inherits elements from the super class hierarchy</p>
+<p>A class can specify a single super class and inherits elements from the super class hierarchy</p>
<p>When a ROOM class specifies a super class, it generally inherits all elements and properties.<br>In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.<br>Refinement is used in most cases (e.g. StateMachine) and realizes an extension of the overridden elements.<br>In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.<br>Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.</p>
-<p>A formal definition of overriding is given below:</p>
+<p>A formal definition of several variants of overriding is given below:</p>
<ul>
- <li>early or late resolve - if element is overridden, which one should super class use by default - own or override ?</li>
- <li>replacing or refinement - ignore inherited code or prepend inherited code automatically ?</li>
- <li>(non-)accessible - if element is overridden, is super class’ original accessible from sub class ? e.g. super.foo()</li>
- <li>implicit or explicit - does it use distinct model element / keyword?</li>
+ <li>early or late resolve - if element is overridden, which one should the super class use by default - own or override?</li>
+ <li>replacing or refining - ignore inherited code or prepend inherited code automatically?</li>
+ <li>(non-)accessible - if element is overridden, is super class’ original accessible from sub class? E.g. super.foo()</li>
+ <li>implicit or explicit - does it use a distinct model element or keyword?</li>
</ul>
-<p>Examples programming languages:<br>c++ virtual function and java override &lt;==&gt; accessible explicit late replacing<br>c++ function redefine &lt;==&gt; accessible implicit early replacing<br>c++ dtor &lt;==&gt; late refinement\</p>
-<p>eTrice override of model elements:<br>Operations (C generation) &lt;==&gt; non_accessible explicit late replacing<br>Operations (Java generation) &lt;==&gt; accessible explicit late replacing<br>State and Transitions &lt;==&gt; non-accessible explicit late refinement<br>ctor/dtor &lt;==&gt; non_accessible implicit late refinement<br>StateMachine &lt;==&gt; non-accessible implicit late refinement<br>UserCode &lt;==&gt; non-accessible implicit late refinement</p>
+<p>Examples from programming languages:<br>C++ virtual function and Java override &lt;==&gt; accessible, explicit, late, replacing<br>C++ function redefine &lt;==&gt; accessible, implicit, early, replacing<br>C++ destructor &lt;==&gt; late, refining\</p>
+<p>eTrice override of model elements:<br>Operations (C generation) &lt;==&gt; non-accessible, explicit, late, replacing<br>Operations (Java generation) &lt;==&gt; accessible, explicit, late, replacing<br>State and Transitions &lt;==&gt; non-accessible, explicit, late, refining<br>ctor/dtor &lt;==&gt; non-accessible, implicit, late, refining<br>StateMachine &lt;==&gt; non-accessible, implicit, late, refining<br>UserCode &lt;==&gt; non-accessible, implicit, late, refining</p>
<table style="vertical-align: middle;" class="table">
<thead>
<tr>
@@ -987,7 +1098,7 @@
</thead>
<tbody>
<tr>
- <td rowspan="4" style="white-space: nowrap;"><p>Is used by:</p></td>
+ <td rowspan="9" style="white-space: nowrap;"><p>Is used by:</p></td>
<td><p><a href="#actorclass">ActorClass</a></p></td>
<td><p>An actor is the basic structural building block for building systems with ROOM</p></td>
</tr>
@@ -996,6 +1107,26 @@
<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
</tr>
<tr>
+ <td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+ <td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+ <td><p><a href="#state">State</a></p></td>
+ <td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+ <td><p><a href="#simplestate">SimpleState</a></p></td>
+ <td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+ <td><p><a href="#refinedstate">RefinedState</a></p></td>
+ <td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
+<tr>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
<td><p><a href="#protocolclass">ProtocolClass</a></p></td>
<td><p>A ProtocolClass defines messages and is the interface specification for a Port</p></td>
</tr>
@@ -1006,42 +1137,61 @@
</tbody>
</table>
<p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; ActorClass ActorSubClass extends ActorBaseClass {&lt;br/&gt; // inherits all elements from super type hierarchy&lt;br/&gt; }&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt; ActorClass ActorBaseClass {
- Interface {
- Port port1 : ProtocolBaseClass
- }
- Structure {
- Attribute attribute1 : uint32
- }
- Behavior {
- Operation operation1() &amp;#39;&amp;#39;&amp;#39;
- return;
- &amp;#39;&amp;#39;&amp;#39;
- }
- }
+<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ActorSubClass <span class="keyword">extends</span> ActorBaseClass {
+ <span class="comment">// inherits all elements from super type hierarchy
+</span>}
- ProtocolClass ProtocolSubClass extends ProtocolBaseClass {
- // inherits all elements from super type hierarchy
- }
+<span class="keyword">ActorClass</span> ActorBaseClass {
+ <span class="keyword">Interface</span> {
+ <span class="keyword">Port</span> port1 : ProtocolBaseClass
+ }
+ <span class="keyword">Structure</span> {
+ <span class="keyword">Attribute</span> attribute1 : uint32
+ }
+ <span class="keyword">Behavior</span> {
+ <span class="keyword">Operation</span> operation1() <span class="string">'''
+ return;
+ '''</span>
+ }
+}
- ProtocolClass ProtocolBaseClass {
- incoming {
- Message message1()
- }
- }
+<span class="keyword">ProtocolClass</span> ProtocolSubClass <span class="keyword">extends</span> ProtocolBaseClass {
+ <span class="comment">// inherits all elements from super type hierarchy
+</span>}
- DataClass DataSubClass extends DataBaseClass {
- // inherits all elements from super type hierarchy
- }
+<span class="keyword">ProtocolClass</span> ProtocolBaseClass {
+ <span class="keyword">incoming</span> {
+ <span class="keyword">Message</span> message1()
+ }
+}
- DataClass DataBaseClass {
- Attribute attribute1 : uint32
- }
- ```
- ¦¦¦
+<span class="keyword">DataClass</span> DataSubClass <span class="keyword">extends</span> DataBaseClass {
+ <span class="comment">// inherits all elements from super type hierarchy
+</span>}
-</p><hr>
+<span class="keyword">DataClass</span> DataBaseClass {
+ <span class="keyword">Attribute</span> attribute1 : uint32
+}
+</code></pre>
+<hr>
+<h3><a href="#initialtransition" name="initialtransition"></a>InitialTransition</h3>
+<p>the initial transition is used to identify the initial state</p>
+<p>The initial transition connects the initial point to a state. There can be at most one initial transition<br> in a state machine. Under special circumstances the initial transition can be omitted.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#internalendport" name="internalendport"></a>InternalEndPort</h3>
<p>A InternalEndPort is an local Port, that is declared in the internal interface of an ActorClass</p>
<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> InternalEndPortExample {
@@ -1140,7 +1290,7 @@
</tr>
<tr>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
</tbody>
</table>
@@ -1228,44 +1378,43 @@
</tbody>
</table>
<p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; import room.basic.types.* from &amp;ldquo;../../../org.eclipse.etrice.modellib.c/model/Types.room&amp;rdquo;&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt; DataClass DataClassWithOperation {
- Attribute attribute1 : uint32
-
- Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
- return attribute1 &amp;gt; (param1 - param2);
- &amp;#39;&amp;#39;&amp;#39;
- }
+<pre><code class="room customHighlighted"><span class="keyword">import</span> room.basic.types.* <span class="keyword">from</span> <span class="string">"../../../org.eclipse.etrice.modellib.c/model/Types.room"</span>
- ActorClass ActorClassWithOperation {
- Structure {
- Attribute attribute1 : uint32
- }
- Behavior {
- Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
- return attribute1 &amp;gt; (param1 - param2);
- &amp;#39;&amp;#39;&amp;#39;
- }
- }
+<span class="keyword">DataClass</span> DataClassWithOperation {
+ <span class="keyword">Attribute</span> attribute1 : uint32
+
+ <span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
+ return attribute1 &gt; (param1 - param2);
+ '''</span>
+}
- ActorClass ActorClassWithOperation2 {
- Structure {
- usercode1 &amp;#39;&amp;#39;&amp;#39;
- // #include &amp;lt;___.h&amp;gt; /* User includes here */
- &amp;#39;&amp;#39;&amp;#39;
- Attribute someHandle : voidType ref
- }
- Behavior {
- Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
- // external calls or casts may need includes
- write(someHandle, param1);
- &amp;#39;&amp;#39;&amp;#39;
- }
- }
- ```
-¦¦¦
+<span class="keyword">ActorClass</span> ActorClassWithOperation {
+ <span class="keyword">Structure</span> {
+ <span class="keyword">Attribute</span> attribute1 : uint32
+ }
+ <span class="keyword">Behavior</span> {
+ <span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
+ return attribute1 &gt; (param1 - param2);
+ '''</span>
+ }
+}
-</p><hr>
+<span class="keyword">ActorClass</span> ActorClassWithOperation2 {
+ <span class="keyword">Structure</span> {
+ <span class="keyword">usercode1</span> <span class="string">'''
+ // #include &lt;___.h&gt; /* User includes here */
+ '''</span>
+ <span class="keyword">Attribute</span> someHandle : voidType <span class="keyword">ref</span>
+ }
+ <span class="keyword">Behavior</span> {
+ <span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
+ // external calls or casts may need includes
+ write(someHandle, param1);
+ '''</span>
+ }
+}
+</code></pre>
+<hr>
<h3><a href="#port" name="port"></a>Port</h3>
<p>A Port is an instance of a ProtocolClass and the interface for an ActorClass</p>
<p>Once a ProtocolClass has been created, it can be used to define actor interfaces. This is accomplished by means of Ports.<br>A Port is a declaration that the set of messages defined by its ProtocolClass is now part of the actor’s interface.<br>It provides strong decoupling of ActorClasses from each other, thus enabling easy testability, reusability and deployment of actors to different threads or nodes.</p>
@@ -1435,12 +1584,12 @@
</tr>
<tr>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
<td><p><a href="#inheritance">Inheritance</a></p></td>
- <td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
</tr>
</tbody>
</table>
@@ -1509,6 +1658,33 @@
</span>}
</code></pre>
<hr>
+<h3><a href="#refinedstate" name="refinedstate"></a>RefinedState</h3>
+<p>A RefinedState refines a State of one of the Actor’s base class state machines</p>
+<p>A State can be a plain State or a RefinedState.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#state">State</a></p></td>
+ <td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#inheritance">Inheritance</a></p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+<tr>
+ <td><p><a href="#statemachine">StateMachine</a></p></td>
+ <td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#relayport" name="relayport"></a>RelayPort</h3>
<p>A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass</p>
<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> RelayPortExample{
@@ -1700,9 +1876,131 @@
</tbody>
</table>
<hr>
+<h3><a href="#simplestate" name="simplestate"></a>SimpleState</h3>
+<p>A State is a node in the state graph representation of the state machine</p>
+<p>A State has optional ‘entry’ and ‘exit’ codes. The entry code is executed when the state is entered, the exit code is executed<br>when it is left. In the case of an data driven (also known as polled) state machine, there also is a ‘do’ action code.<br>The do code is executed for the active state in each polling cycle.<br>A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines<br>form a tree which is called a ‘hierarchical state machine’.<br>A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#state">State</a></p></td>
+ <td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#inheritance">Inheritance</a></p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+<tr>
+ <td><p><a href="#statemachine">StateMachine</a></p></td>
+ <td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#state" name="state"></a>State</h3>
+<p>A State can be a plain State or a RefinedState</p>
+<p>A State can be a plain State or a RefinedState.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+ <td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#inheritance">Inheritance</a></p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+ <td><p><a href="#simplestate">SimpleState</a></p></td>
+ <td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+ <td><p><a href="#refinedstate">RefinedState</a></p></td>
+ <td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#stategraphnode" name="stategraphnode"></a>StateGraphNode</h3>
+<p>A StateGraphNode is an abstract node of the state graph</p>
+<p>A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#inheritance">Inheritance</a></p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="3" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+ <td><p><a href="#state">State</a></p></td>
+ <td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+ <td><p><a href="#choicepoint">ChoicePoint</a></p></td>
+ <td><p>a choice point is the state machine counterpart of a conditional statement</p></td>
+</tr>
+<tr>
+ <td><p><a href="#trpoint">TrPoint</a></p></td>
+ <td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
+ <td><p><a href="#statemachine">StateMachine</a></p></td>
+ <td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h3><a href="#statemachine" name="statemachine"></a>StateMachine</h3>
<p>A StateMachine describes the state based, event driven behavior of an ActorClass</p>
-<p>In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.</p>
+<p>In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will<br>be forwarded to and processed by the state machine. Events possibly trigger state transitions.</p>
+<p>ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.<br>This is possible to arbitrary depth.</p>
+<p>A state graph consists of</p>
+<ul>
+ <li>states</li>
+ <li>transitions</li>
+ <li>transition points</li>
+ <li>choice points</li>
+ <li>initial point</li>
+</ul>
<p><img src="images/300-PingPongReceiverFSM.png" alt="PingPongReceiverFSM"></p>
<table style="vertical-align: middle;" class="table">
<thead>
@@ -1712,9 +2010,18 @@
</thead>
<tbody>
<tr>
+ <td rowspan="2" style="white-space: nowrap;"><p>Contains:</p></td>
+ <td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+ <td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
<td><p><a href="#inheritance">Inheritance</a></p></td>
- <td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
</tr>
</tbody>
</table>
@@ -1735,6 +2042,15 @@
<td><p><a href="#graphicalbehavioreditor">GraphicalBehaviorEditor</a></p></td>
<td><p>The GraphicalBehaviorEditor allows to edit the ActorClass’ StateMachine. It is possible to create (hierarchical) states and transitions to model complex behavior in a convenient way.</p></td>
</tr>
+<tr>
+ <td rowspan="2" style="white-space: nowrap;"><p>Is used by:</p></td>
+ <td><p><a href="#simplestate">SimpleState</a></p></td>
+ <td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+ <td><p><a href="#refinedstate">RefinedState</a></p></td>
+ <td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
</tbody>
</table>
<hr>
@@ -1763,7 +2079,7 @@
</tr>
<tr>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
</tbody>
</table>
@@ -1825,6 +2141,131 @@
</tbody>
</table>
<hr>
+<h3><a href="#trpoint" name="trpoint"></a>TrPoint</h3>
+<p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+ <td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="3" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+ <td><p><a href="#transitionpoint">TransitionPoint</a></p></td>
+ <td><p>a transition point is the starting point of transitions that trigger for any state of this state machine</p></td>
+</tr>
+<tr>
+ <td><p><a href="#entrypoint">EntryPoint</a></p></td>
+ <td><p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p></td>
+</tr>
+<tr>
+ <td><p><a href="#exitpoint">ExitPoint</a></p></td>
+ <td><p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#transition" name="transition"></a>Transition</h3>
+<p>A Transition is an edge in the state graph representation of the state machine</p>
+<p>A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.<br>Transition points can only be targets of transitions originating from the same transition point.<br>The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+ <td><p><a href="#inheritance">Inheritance</a></p></td>
+ <td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="4" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+ <td><p><a href="#initialtransition">InitialTransition</a></p></td>
+ <td><p>the initial transition is used to identify the initial state</p></td>
+</tr>
+<tr>
+ <td><p><a href="#continuationtransition">ContinuationTransition</a></p></td>
+ <td><p>the continuation transition is a transition with just an optional action code</p></td>
+</tr>
+<tr>
+ <td><p><a href="#cpbranchtransition">CPBranchTransition</a></p></td>
+ <td><p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p></td>
+</tr>
+<tr>
+ <td><p><a href="#triggeredtransition">TriggeredTransition</a></p></td>
+ <td><p>a triggered transition is used in event driven state machines to trigger state transitions</p></td>
+</tr>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
+ <td><p><a href="#statemachine">StateMachine</a></p></td>
+ <td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#transitionpoint" name="transitionpoint"></a>TransitionPoint</h3>
+<p>a transition point is the starting point of transitions that trigger for any state of this state machine</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#trpoint">TrPoint</a></p></td>
+ <td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#triggeredtransition" name="triggeredtransition"></a>TriggeredTransition</h3>
+<p>a triggered transition is used in event driven state machines to trigger state transitions</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+ <th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+ <td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+ <td><p><a href="#transition">Transition</a></p></td>
+ <td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
<h2><a href="#mappingmodel" name="mappingmodel"></a>MappingModel</h2>
<p>The MappingModel describes the mapping of elements of the LogicalModel to elements of the PhysicalModel</p>
<p>It enables the complete decoupling of the LogicalModel and the PhysicalModel, thus providing a maximum flexibility and reuse for the models.</p>
@@ -2279,7 +2720,7 @@
<tr>
<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
<td><p><a href="#annotation">Annotation</a></p></td>
- <td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+ <td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
</tr>
</tbody>
</table>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
index 383434f5f..e6ec50cc0 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
@@ -120,21 +120,21 @@
<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ActorClass4 {
<span class="keyword">Behavior</span> {
<span class="comment">// no arguments, no return value
-</span> <span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> '''
+</span> <span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// argument of primitive type, return value of primitive type
-</span> <span class="keyword">Operation</span> operation2(Param1: int32, Param2: float64): uint16 '''
+</span> <span class="keyword">Operation</span> operation2(Param1: int32, Param2: float64): uint16 <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// arguments and return value by value
-</span> <span class="keyword">Operation</span> operation3(Param1: int32, Param2: DataClass1): DataClass1 '''
+</span> <span class="keyword">Operation</span> operation3(Param1: int32, Param2: DataClass1): DataClass1 <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// arguments and return value by reference except for primitive types
-</span> <span class="keyword">Operation</span> operation4(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> '''
+</span> <span class="keyword">Operation</span> operation4(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> <span class="string">'''
user code
- '''
+ '''</span>
}
}
</code></pre>
@@ -376,17 +376,17 @@
</span> <span class="keyword">Attribute</span> attribute2: float32 <span class="comment">// attribute of another primitive type
</span>
<span class="comment">// no arguments, no return value
-</span> <span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> '''
+</span> <span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// argument of primitive type, no return value
-</span> <span class="keyword">Operation</span> operation2(Param1: int32): <span class="keyword">void</span> '''
+</span> <span class="keyword">Operation</span> operation2(Param1: int32): <span class="keyword">void</span> <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// argument of primitive type, return value of primitive type
-</span> <span class="keyword">Operation</span> operation3(Param1: int32): float64 '''
+</span> <span class="keyword">Operation</span> operation3(Param1: int32): float64 <span class="string">'''
user code
- '''
+ '''</span>
}
</code></pre>
<p>Example: DataClass using other DataClasses:</p>
@@ -395,13 +395,13 @@
</span> <span class="keyword">Attribute</span> attribute2: DataClass1 <span class="comment">// attribute of DataClass
</span>
<span class="comment">// arguments and return value by value
-</span> <span class="keyword">Operation</span> operation1(Param1: int32, Param2: DataClass1): DataClass1 '''
+</span> <span class="keyword">Operation</span> operation1(Param1: int32, Param2: DataClass1): DataClass1 <span class="string">'''
user code
- '''
+ '''</span>
<span class="comment">// arguments and return value by reference except for primitive types
-</span> <span class="keyword">Operation</span> operation2(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> '''
+</span> <span class="keyword">Operation</span> operation2(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> <span class="string">'''
user code
- '''
+ '''</span>
}
</code></pre>
<h2><a href="#layering" name="layering"></a>Layering</h2>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
index df79d8ddd..57f009c26 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
@@ -95,14 +95,20 @@
</topic><topic href="targets/eclipse-help/feature-reference.html#annotationtype" label="AnnotationType">
</topic><topic href="targets/eclipse-help/feature-reference.html#attribute" label="Attribute">
</topic><topic href="targets/eclipse-help/feature-reference.html#binding" label="Binding">
+</topic><topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="CPBranchTransition">
+</topic><topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ChoicePoint">
</topic><topic href="targets/eclipse-help/feature-reference.html#communicationtype" label="CommunicationType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ContinuationTransition">
</topic><topic href="targets/eclipse-help/feature-reference.html#dataclass" label="DataClass">
</topic><topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="EntryPoint">
</topic><topic href="targets/eclipse-help/feature-reference.html#enumeration" label="Enumeration">
</topic><topic href="targets/eclipse-help/feature-reference.html#executiontype" label="ExecutionType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="ExitPoint">
</topic><topic href="targets/eclipse-help/feature-reference.html#externalendport" label="ExternalEndPort">
</topic><topic href="targets/eclipse-help/feature-reference.html#externaltype" label="ExternalType">
</topic><topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Inheritance">
+</topic><topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="InitialTransition">
</topic><topic href="targets/eclipse-help/feature-reference.html#internalendport" label="InternalEndPort">
</topic><topic href="targets/eclipse-help/feature-reference.html#layerconnection" label="LayerConnection">
</topic><topic href="targets/eclipse-help/feature-reference.html#logicalsystem" label="LogicalSystem">
@@ -110,14 +116,22 @@
</topic><topic href="targets/eclipse-help/feature-reference.html#port" label="Port">
</topic><topic href="targets/eclipse-help/feature-reference.html#primitivetype" label="PrimitiveType">
</topic><topic href="targets/eclipse-help/feature-reference.html#protocolclass" label="ProtocolClass">
+</topic><topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="RefinedState">
</topic><topic href="targets/eclipse-help/feature-reference.html#relayport" label="RelayPort">
</topic><topic href="targets/eclipse-help/feature-reference.html#replication" label="Replication">
</topic><topic href="targets/eclipse-help/feature-reference.html#sap" label="SAP">
</topic><topic href="targets/eclipse-help/feature-reference.html#spp" label="SPP">
</topic><topic href="targets/eclipse-help/feature-reference.html#serviceimplementation" label="ServiceImplementation">
+</topic><topic href="targets/eclipse-help/feature-reference.html#simplestate" label="SimpleState">
+</topic><topic href="targets/eclipse-help/feature-reference.html#state" label="State">
+</topic><topic href="targets/eclipse-help/feature-reference.html#stategraphnode" label="StateGraphNode">
</topic><topic href="targets/eclipse-help/feature-reference.html#statemachine" label="StateMachine">
</topic><topic href="targets/eclipse-help/feature-reference.html#subsystemclass" label="SubSystemClass">
</topic><topic href="targets/eclipse-help/feature-reference.html#subsystemref" label="SubSystemRef">
+</topic><topic href="targets/eclipse-help/feature-reference.html#trpoint" label="TrPoint">
+</topic><topic href="targets/eclipse-help/feature-reference.html#transition" label="Transition">
+</topic><topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TransitionPoint">
+</topic><topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="TriggeredTransition">
</topic>
</topic><topic href="targets/eclipse-help/feature-reference.html#mappingmodel" label="MappingModel">
</topic><topic href="targets/eclipse-help/feature-reference.html#physicalmodel" label="PhysicalModel">
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html
new file mode 100644
index 000000000..c00599a38
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p>
+<p>Transition tr3: cp cp0 -&gt; state1 {<br/> cond &rsquo;&lsquo;&lsquo;0&lt;=counter &amp;&amp; counter&lt;3&rsquo;&rsquo;&rsquo;<br/>}</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html
new file mode 100644
index 000000000..77265f187
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html
@@ -0,0 +1,31 @@
+<!-- generated by featurizer -->
+<p>a choice point is the state machine counterpart of a conditional statement</p>
+<pre><code class=room customHighlighted> <span class=keyword>StateMachine</span> {
+ <span class=keyword>State</span> state0
+ <span class=keyword>State</span> state1
+ <span class=keyword>State</span> state2
+ <span class=keyword>State</span> state3
+ <span class=keyword>TransitionPoint</span> tr4
+ <span class=keyword>ChoicePoint</span> cp0
+ <span class=keyword>Transition</span> init0: <span class=keyword>initial</span> -&gt; state0
+ <span class=keyword>Transition</span> tr0: state0 -&gt; state1 {
+ <span class=keyword>triggers</span> {
+ &lt;in1: p0&gt;
+ }
+ }
+ <span class=keyword>Transition</span> tr1: state1 -&gt; <span class=keyword>cp</span> cp0 {
+ <span class=keyword>triggers</span> {
+ &lt;in1: p0&gt;
+ }
+ }
+ <span class=keyword>Transition</span> tr2: <span class=keyword>cp</span> cp0 -&gt; state3
+ <span class=keyword>Transition</span> tr3: <span class=keyword>cp</span> cp0 -&gt; state2 {
+ <span class=keyword>cond</span> <span class=string>&#39;&#39;&#39;true&#39;&#39;&#39;</span>
+ }
+ <span class=keyword>Transition</span> tr5: <span class=keyword>my</span> tr4 -&gt; state0 {
+ <span class=keyword>triggers</span> {
+ &lt;in2: p0&gt;
+ }
+ }
+ }
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html
new file mode 100644
index 000000000..85175b1e3
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>the continuation transition is a transition with just an optional action code</p>
+<p>State running {<br/> subgraph {<br/> EntryPoint ep0<br/> State active<br/> Transition tr0: my ep0 -&gt; active<br/> }<br/>}</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html
new file mode 100644
index 000000000..3ab8d464f
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html
@@ -0,0 +1,21 @@
+<!-- generated by featurizer -->
+<p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p>
+<pre><code class=room customHighlighted> <span class=keyword>StateMachine</span> {
+ <span class=keyword>State</span> state0 {
+ <span class=keyword>subgraph</span> {
+ <span class=keyword>State</span> state0
+ <span class=keyword>EntryPoint</span> ep0
+ <span class=keyword>ExitPoint</span> ep1
+ <span class=keyword>Transition</span> tr0: <span class=keyword>my</span> ep0 -&gt; state0
+ <span class=keyword>Transition</span> tr1: state0 -&gt; <span class=keyword>my</span> ep1 {
+ <span class=keyword>triggers</span> {
+ &lt;in1: p0&gt;
+ }
+ }
+ }
+ }
+ <span class=keyword>State</span> state1
+ <span class=keyword>Transition</span> init0: <span class=keyword>initial</span> -&gt; ep0 <span class=keyword>of</span> state0
+ <span class=keyword>Transition</span> tr0: ep1 <span class=keyword>of</span> state0 -&gt; state1
+ }
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html
new file mode 100644
index 000000000..4b7a6254c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p>
+<p>help</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html
new file mode 100644
index 000000000..6d2f2e7dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>the guarded transition is used by data driven state machines to trigger state transitions</p>
+<p>Transition tr: running -&gt; running {<br/> guard &rsquo;&lsquo;&lsquo;data_counter_finish.finish == true &amp;&amp; data_finish_flag == false&rsquo;&rsquo;&lsquo;<br/> action &rsquo;&rsquo;&lsquo;++counter;&rsquo;&rsquo;&rsquo;<br/>}</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html
new file mode 100644
index 000000000..192c2443a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>the initial transition is used to identify the initial state</p>
+<p>Transition init: initial -&gt; state0</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
index 482f17025..db0a7c739 100644
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
@@ -1,6 +1,6 @@
<!-- generated by featurizer -->
<p>A PrimitiveType is an abstraction of a target language&rsquo;s basic type (e.g. integer or boolean)</p>
-<pre><code class=room customHighlighted><span class=comment>// java
+<pre><code class=room customHighlighted><span class=comment>// Java
</span><span class=keyword>PrimitiveType</span> boolean: <span class=keyword>ptBoolean</span> -&gt; boolean (Boolean) <span class=keyword>default</span> <span class=string>&quot;false&quot;</span>
<span class=keyword>PrimitiveType</span> int16: <span class=keyword>ptInteger</span> -&gt; short (Short) <span class=keyword>default</span> <span class=string>&quot;0&quot;</span>
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html
new file mode 100644
index 000000000..c8cd2ce86
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html
@@ -0,0 +1,11 @@
+<!-- generated by featurizer -->
+<p>A RefinedState refines a State of one of the Actor&rsquo;s base class state machines</p>
+<pre><code class=room customHighlighted> <span class=keyword>RefinedState</span> BaseState {
+ <span class=keyword>exit</span> <span class=string>&#39;&#39;&#39;// this is derived exit code&#39;&#39;&#39;</span>
+ <span class=keyword>subgraph</span> {
+ <span class=comment>// add a sub state machine
+</span> <span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; state0 { }
+ <span class=keyword>State</span> state0
+ }
+ }
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html
new file mode 100644
index 000000000..d032d034d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html
@@ -0,0 +1,33 @@
+<!-- generated by featurizer -->
+<p>A State is a node in the state graph representation of the state machine</p>
+<pre><code class=room customHighlighted><span class=keyword>ActorClass</span> Example {
+ <span class=comment>//...
+</span> <span class=keyword>Behavior</span> {
+ <span class=keyword>StateMachine</span> {
+ <span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; Standby
+ <span class=keyword>Transition</span> tr0: Standby -&gt; Running {
+ <span class=keyword>triggers</span> {
+ &lt;timeout: to&gt;
+ }
+ }
+ <span class=keyword>Transition</span> tr1: Running -&gt; Stopped {
+ <span class=keyword>triggers</span> {
+ &lt;timeout: to&gt;
+ }
+ }
+ <span class=keyword>State</span> Standby {
+ <span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;
+ to.startTimeout(200*10);&#39;&#39;&#39;</span>
+ }
+ <span class=keyword>State</span> Running {
+ <span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;
+ controllers.start();
+ to.startTimeout(200*10);&#39;&#39;&#39;</span>
+ }
+ <span class=keyword>State</span> Stopped {
+ <span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;controllers.stop();&#39;&#39;&#39;</span>
+ }
+ }
+ }
+}
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html
new file mode 100644
index 000000000..d508117e0
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p>
+<p>a TrPoint is an abstract element</p> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html
new file mode 100644
index 000000000..dc7ac5abc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html
@@ -0,0 +1,9 @@
+<!-- generated by featurizer -->
+<p>A Transition is an edge in the state graph representation of the state machine</p>
+<pre><code class=room customHighlighted> <span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; Standby
+ <span class=keyword>Transition</span> tr0: Standby -&gt; Running {
+ <span class=keyword>triggers</span> {
+ &lt;timeout: to&gt;
+ }
+ }
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html
new file mode 100644
index 000000000..ddcc4f441
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html
@@ -0,0 +1,11 @@
+<!-- generated by featurizer -->
+<p>a transition point is the starting point of transitions that trigger for any state of this state machine</p>
+<pre><code class=room customHighlighted> <span class=keyword>StateMachine</span> {
+ <span class=keyword>TransitionPoint</span> tp1
+ <span class=keyword>Transition</span> tr1: <span class=keyword>my</span> tp1 -&gt; <span class=keyword>my</span> tp1 {
+ <span class=keyword>triggers</span> {
+ &lt;msg: port&gt;
+ }
+ }
+ }
+</code></pre> \ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html
new file mode 100644
index 000000000..927701086
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html
@@ -0,0 +1,3 @@
+<!-- generated by featurizer -->
+<p>a triggered transition is used in event driven state machines to trigger state transitions</p>
+<p>help</p> \ No newline at end of file

Back to the top