261:. That means that an actor is processing a message completely before it accepts the next message. Since the run-to-completion semantics is guaranteed by the execution environment, the programmer/modeler doesn't have to deal with classical thread synchronization. And this despite the fact that typical ROOM systems are highly concurrent because of the asynchronous communication. And maybe its worth to stress that the asynchronous nature of ROOM systems is not by accident but reflects the inherent asynchronicity of e.g. the machine being controlled by the software. Definitely this requires another mind set than the one that is needed for functional programming of synchronous systems. But after a short while of getting accustomed it will be evident that asynchronously communicating state machines are perfectly suited for control software.
142:
220:
411:
117:
is assigned. A protocol in ROOM defines a set of outgoing and a set of incoming messages. Ports can be connected with a binding if they belong to the same protocol and are conjugate to each other. That means that one port is sending the outgoing messages of the protocol and receiving the incoming
312:
for the server side. From the point of view of an actor implementation the SAPs and SPPs work like ports. Like ports they are associated with a protocol. But other than ports they don't have to (and even cannot) be bound explicitly. Rather, an actor is bound to a concrete service by a
253:
A state machine can also have a hierarchy in the sense that states can have sub state machines. Similar to the structure this can be extended to arbitrary depth. For details of the semantics of hierarchical state machines we refer to the original book.
74:
for the whole system from the model. ROOM comes with a textual as well as with a graphical notation. Typically the generated code is accompanied with manually written code, e.g. for graphical user interfaces
216:
if the state machine is in the source state of the transition and a message of the type specified by the trigger arrives. Afterwards the state is changed to the target state of the transition.
292:). It inherits all features of the base class like ports and actor refs, but also the state machine. The derived actor class can add further states and transitions to the inherited one.
227:
During the state change certain pieces of code are executed. The programmer (or modeler) can attach them to the states and transitions. In ROOM this code is written in the so called
164:
The actor's ports can be part of its interface (visible from the exterior) or part of its structure (used by itself) or both. Ports that are part of the interface only are called
243:
of the firing transition is executed and finally the entry code of the target state. A typical part of those codes is the sending of messages through ports of the actor.
281:
several times in the system. Of course each instance of an actor class tracks its own state and can communicate with other instances of the same (and other) classes.
82:
ROOM describes a software system along three dimensions: structure, behavior and inheritance. The following sections will explain these three aspects in more detail.
436:
415:
285:
200:. State transitions are triggered by incoming messages from an internal or external end port. In this context the messages sometimes are also called
168:. They are directly connected to a port of a sub actor (they are delegating to the sub actor). Ports that are part of the structure only are called
394:
367:
335:
304:. This notion refers to the vertical layers of a software system consisting of services and their clients. ROOM introduces the notions of
451:
345:
441:
126:
port, receives the outgoing messages and sends the incoming ones of the protocol. In other words, a port is the combination of a
446:
79:). The code is compiled and linked against a runtime library which provides base classes and basic services (e.g. messaging).
389:
Bran Selic, Garth
Gullekson, Paul T. Ward: "Real-Time Object-Oriented Modeling", New York, John Wiley & Sons Inc, 1994,
330:
Bran Selic, Garth
Gullekson, Paul T. Ward: "Real-Time Object-Oriented Modeling", New York, John Wiley & Sons Inc, 1994,
431:
317:
and this binding of a service is propagated recursively to all sub actors of this actor. This concept is very similar to
274:
278:
270:
340:
New edition: Bran Selic, Garth
Gullekson, Paul T. Ward: "Real-Time Object-Oriented Modeling", Hamburg, MBSE4U, 2023,
110:
59:
55:
46:
24:
288:
of actor classes. It is a single inheritance as an actor class can be derived from another actor class (its
71:
318:
185:
42:
150:
390:
341:
331:
247:
35:
31:
141:
70:
ROOM is a modeling language for the definition of software systems. It allows the complete
107:
189:
239:. During a state change first the exit code of the source state is executed. Then the
219:
425:
257:
An important concept in the context of state machines is the execution model of
184:
Each actor in ROOM has a behavior which is defined by means of a hierarchical
161:
for short. This allows to create structural hierarchies of arbitrary depth.
138:(since one and the same protocol can be used by several ports of an actor).
410:
38:, even though ROOM can be applied to any event-driven real-time system.
231:, usually the target language of the code generation. A state can have
246:
State machines in ROOM also have a graphical notation similar to the
49:
218:
140:
172:. Ports that belong to both, structure and interface, are called
378:
62:
with real time extensions), many elements of ROOM were adopted.
76:
284:
Similar to other modern programming languages ROOM allows
368:
Summary of the book "Real-Time Object-Oriented
Modeling"
188:, or just state machine for short. A state machine is a
223:
ROOM behavior diagramm (state machine as a state chart)
250:. An example is shown in the diagram in this section.
45:(commercial) and is now implemented by the official
363:
361:
30:ROOM was developed in the early 1990s for modeling
277:. Actors are classes which can be instantiated as
98:. Actors can communicate with each other using
113:via ports and bindings. To each port a unique
8:
90:The structural view in ROOM is composed of
149:An actor can contain other actors (as a
357:
208:. If a transition specifies a certain
271:object-oriented programming languages
7:
300:A last powerful concept of ROOM is
416:Real-Time Object-Oriented Modeling
17:Real-Time Object-Oriented Modeling
14:
437:Architecture description language
409:
66:Concepts and key notions of ROOM
102:. Those ports are connected by
379:eTrice - ROOM Open Source Tool
145:Example of a structure diagram
118:ones. This port is called the
1:
310:service provision point (SPP)
153:). In ROOM these are called
192:consisting of nodes called
34:. The initial focus was on
468:
452:Software modeling language
306:service access point (SAP)
58:was defined (version 2 of
273:ROOM uses the concept of
122:port. Its peer port, the
308:for the client side and
25:domain-specific language
442:Data modeling languages
447:Data modeling diagrams
224:
146:
41:ROOM was supported by
229:detail level language
222:
144:
432:Real-time technology
418:at Wikimedia Commons
319:dependency injection
186:finite-state machine
212:then it is said to
43:ObjecTime Developer
225:
174:external end ports
170:internal end ports
147:
132:provided interface
36:telecommunications
414:Media related to
395:978-0-471-59917-3
336:978-0-471-59917-3
259:run-to-completion
196:and edges called
108:exchange messages
32:real-time systems
459:
413:
397:
387:
381:
376:
370:
365:
315:layer connection
248:UML state charts
155:actor references
467:
466:
462:
461:
460:
458:
457:
456:
422:
421:
406:
401:
400:
388:
384:
377:
373:
366:
359:
354:
327:
298:
267:
182:
88:
72:code generation
68:
47:Eclipse project
12:
11:
5:
465:
463:
455:
454:
449:
444:
439:
434:
424:
423:
420:
419:
405:
404:External links
402:
399:
398:
382:
371:
356:
355:
353:
350:
349:
348:
346:978-3911081016
338:
326:
323:
297:
294:
266:
263:
190:directed graph
181:
178:
111:asynchronously
87:
84:
67:
64:
13:
10:
9:
6:
4:
3:
2:
464:
453:
450:
448:
445:
443:
440:
438:
435:
433:
430:
429:
427:
417:
412:
408:
407:
403:
396:
392:
386:
383:
380:
375:
372:
369:
364:
362:
358:
351:
347:
343:
339:
337:
333:
329:
328:
324:
322:
320:
316:
311:
307:
303:
295:
293:
291:
287:
282:
280:
276:
272:
264:
262:
260:
255:
251:
249:
244:
242:
238:
234:
230:
221:
217:
215:
211:
207:
203:
199:
195:
191:
187:
179:
177:
175:
171:
167:
162:
160:
156:
152:
143:
139:
137:
133:
129:
125:
121:
116:
112:
109:
105:
101:
97:
93:
85:
83:
80:
78:
73:
65:
63:
61:
57:
52:
51:
48:
44:
39:
37:
33:
28:
26:
22:
18:
385:
374:
314:
309:
305:
301:
299:
289:
283:
268:
258:
256:
252:
245:
240:
236:
232:
228:
226:
213:
209:
205:
201:
197:
193:
183:
173:
169:
165:
163:
158:
154:
148:
135:
131:
127:
123:
119:
114:
106:. Actors do
103:
99:
95:
91:
89:
81:
69:
53:
40:
29:
20:
16:
15:
286:inheritance
269:Like other
265:Inheritance
241:action code
198:transitions
166:relay ports
151:composition
426:Categories
352:References
325:Literature
290:base class
233:entry code
159:actor refs
124:conjugated
237:exit code
86:Structure
302:layering
296:Layering
180:Behavior
128:required
115:protocol
104:bindings
96:capsules
279:objects
275:classes
210:trigger
206:signals
120:regular
23:) is a
393:
344:
334:
202:events
194:states
130:and a
92:actors
50:eTrice
134:in a
100:ports
54:When
391:ISBN
342:ISBN
332:ISBN
235:and
214:fire
136:role
56:UML2
21:ROOM
204:or
157:or
94:or
77:GUI
60:UML
428::
360:^
321:.
176:.
27:.
75:(
19:(
Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.
