Altova UModel 2016

Transcription

Altova UModel 2016

Benutzer- und Referenzhandbuch
Altova UModel 2017 Benutzer- und
Referenzhandbuch
All rights reserved. No parts of this work may be reproduced in any form or by any
means - graphic, electronic, or mechanical, including photocopying, recording, taping, or
information storage and retrieval systems - without the written permission of the
publisher.
Products that are referred to in this document may be either trademarks and/or
registered trademarks of the respective owners. The publisher and the author make no
claim to these trademarks.
While every precaution has been taken in the preparation of this document, the
publisher and the author assume no responsibility for errors or omissions, or for
damages resulting from the use of information contained in this document or from the
use of programs and source code that may accompany it. In no event shall the publisher
and the author be liable for any loss of profit or any other commercial damage caused or
alleged to have been caused directly or indirectly by this document.
Published: 2016
© 2016 Altova GmbH
UML®, OMG™, Object Management Group™, and Unified Modeling Language™ are
either registered trademarks or trademarks of Object Management Group, Inc. in the
United States and/or other countries.
Inhaltsverzeichnis
1
UModel
3
2
Einführung in UModel
6
3
UModel Tutorial
3.1
Starten von
.................................................................................................................
UModel
12
3.2
Use Cases
................................................................................................................. 16
3.3
Klassendiagramme
................................................................................................................. 25
3.3.1 Erstellen...................................................................................................
von abgeleiteten Klassen
32
3.4
Objektdiagramme
................................................................................................................. 37
3.5
Komponentendiagramme
................................................................................................................. 43
3.6
Deployment-Diagramme
................................................................................................................. 48
3.7
Round-Trip
.................................................................................................................
Engineering (Modell - Code - Modell)
52
3.8
Round-Trip
.................................................................................................................
Engineering (Code - Modell - Code)
59
4
UModel Benutzeroberfläche
4.1
Modell-Struktur
................................................................................................................. 69
4.2
Diagramm-Struktur
................................................................................................................. 74
4.3
Favoriten
................................................................................................................. 76
4.4
Eigenschaften
................................................................................................................. 78
4.5
Stile
4.6
Hierarchie
................................................................................................................. 83
4.7
Übersicht
.................................................................................................................
- Dokumentation
86
4.8
Dokumentation
................................................................................................................. 87
4.9
Meldungen
................................................................................................................. 88
10
68
................................................................................................................. 80
4.10 Diagrammfenster
................................................................................................................. 89
4.10.1 Diagrammeigenschaften
................................................................................................... 93
4.10.2 Ausschneiden,
...................................................................................................
Kopieren und Einfügen in UModel Diagramme
95
4.11 Hinzufügen/Einfügen
.................................................................................................................
von Modellelementen
98
4.12 Verknüpfen
.................................................................................................................
von Modellierungselementen
100
Altova UModel 2017
1
4.13 Bank-Beispieldateien
................................................................................................................. 106
5
UModel Befehlszeilenschnittstelle
110
5.1
Datei: New
.................................................................................................................
/ Load / Save-Optionen
114
6
Projekte und Code Engineering
6.1
Mini-UModel
.................................................................................................................
Projekt - von Grund auf neu erstellen
121
6.2
Importieren
.................................................................................................................
von Quellcode in Projekte
126
6.3
Importieren
.................................................................................................................
von Java-, C#- und VB-Binärdateien
131
6.4
Synchronisieren
.................................................................................................................
von Modell und Quellcode
137
6.4.1 Tipps zur
...................................................................................................
Synchronisierung
140
6.4.2
Refactoring
...................................................................................................
und Synchronisierung von Code
142
6.5
Voraussetzungen
.................................................................................................................
für Forward Engineering
144
6.6
Generieren
.................................................................................................................
von Java-Code aus UModel-Elementen und umgekehrt
146
6.7
Generieren
.................................................................................................................
von C#-Code aus UModel Elementen und umgekehrt
147
6.8
XML Schema
.................................................................................................................
von/zu UModel Elementen
148
6.9
Konvertierung
.................................................................................................................
VB.NET-Code - UModel-Elemente
149
118
6.10 Konvertierung
.................................................................................................................
Datenbanken - UModel-Elemente
150
6.11 Inkludieren
.................................................................................................................
anderer UModel-Projekte
151
6.12 Zusammenführen
.................................................................................................................
von UModel-Projekten
153
6.12.1 2-Weg-Projektzusammenführung
................................................................................................... 154
................................................................................................... 155
6.12.3 Beispiel:
...................................................................................................
Manuelle 3-Weg-Projektzusammenführung
158
6.13 Freigeben
.................................................................................................................
von Paketen und Diagrammen
161
6.14 UML-Vorlagen
................................................................................................................. 165
6.14.1 Vorlagensignaturen
................................................................................................... 167
6.14.2 Vorlagenverwendung
................................................................................................... 168
...................................................................................................
in Operationen und Eigenschaften
169
6.15 Projekteinstellungen
................................................................................................................. 170
6.16 Verbesserung
.................................................................................................................
der Performance
171
2
7
Erstellen von Modellbeziehungen
174
7.1
Anzeigen
.................................................................................................................
von Modellbeziehungen
177
7.2
Assoziationen,
.................................................................................................................
Realisierungen und Abhängigkeiten
179
Altova UModel 2017
8
Generieren von UML-Dokumentation
184
8.1
Vordefiniertes
.................................................................................................................
SPS-Stylesheet
190
8.2
Benutzerdefinierte
.................................................................................................................
Stylesheets
191
9
UML-Diagramme
9.1
Verhaltensdiagramme
................................................................................................................. 195
9.1.1 Aktivitätsdiagramm
................................................................................................... 196
...........................................................................................................
197
Einf
ügen von Aktivitätsdiagrammelementen
...........................................................................................................
199
Erstellen
von Verzweigungen und Merges
........................................................................................................... 201
Aktivitätsdiagramm-Elemente
9.1.2
Zustandsdiagramm
................................................................................................... 211
...........................................................................................................
212
Einf
ügen von Zustandsdiagrammelementen
...........................................................................................................
212
Erstellen
von Zuständen, Aktivitäten und Transitionen
...........................................................................................................
219
Zusammengesetzte
Zustände
...........................................................................................................
222
Codegenerierung anhand von Zustandsdiagrammen
...........................................................................................................
225
Arbeiten
mit Zustandsdiagrammcode
........................................................................................................... 231
Zustandsdiagramm-Elemente
9.1.3
Protokoll-Zustandsautomat
................................................................................................... 234
...........................................................................................................
235
Einf
ügen von Protokoll-Zustandsdiagramm-Elementen
........................................................................................................... 236
Protokoll-Zustandsdiagramm-Elemente
9.1.4
Use Case-Diagramm
................................................................................................... 239
9.1.5
Kommunikationsdiagramm
................................................................................................... 240
...........................................................................................................
240
Einf
ügen von Kommunikationsdiagrammelementen
9.1.6
Interaktionsübersichtsdiagramm
................................................................................................... 244
...........................................................................................................
245
Einf
ügen von Interaktionsübersichtselementen
9.1.7
Sequenzdiagramm
................................................................................................... 249
...........................................................................................................
250
Einf
ügen von Sequenzdiagrammelementen
194
......................................................................................................................................... 251
Lebenslinie
.........................................................................................................................................
253
Combined
Fragment
.........................................................................................................................................
256
Interaction
Use
......................................................................................................................................... 256
Gate
......................................................................................................................................... 257
Zustandsinvariante
......................................................................................................................................... 257
Nachrichten
Generieren von Sequenzdiagrammen anhand von
........................................................................................................... 263
Quellcode
...........................................................................................................
266
Eigenschaf
ten
...........................................................................................................
268
Generieren
von Code anhand von Sequenzdiagrammen
.........................................................................................................................................
271
Hinzufügen
von Code zu einem Sequenzdiagramm
9.1.8
Altova UModel 2017
Zeitverlaufsdiagramm
................................................................................................... 275
3
...........................................................................................................
276
Einf
ügen von Elementen des Zeitverlauf sdiagramms
...........................................................................................................
276
Lebenslinie
...........................................................................................................
279
Tick-Sy
mbol
...........................................................................................................
280
Auslösendes
Ereignis
........................................................................................................... 280
Zeitdauerbedingung
........................................................................................................... 281
Zeitbedingung
........................................................................................................... 282
Nachricht
9.2
Strukturdiagramme
................................................................................................................. 284
9.2.1 Klassendiagramm
................................................................................................... 285
...........................................................................................................
285
Anp assen von Klassendiagrammen
Auß erkraf tsetzen von Basisklassenop erationen und
...........................................................................................................
292
Imp
lementieren von Schnittstellenop erationen
...........................................................................................................
293
Erstellen
von Getter / Setter-Methoden
...........................................................................................................
294
Ball-and-socket
Notation
Hinzuf ügen von Ausnahmeereignissen zu Methoden
...........................................................................................................
295
einer
Klasse
...........................................................................................................
296
Generieren
von Klassendiagrammen
9.2.2
Kompositionsstrukturdiagramm
................................................................................................... 300
Einf ügen von Elementen eines
...........................................................................................................
300
Komp
ositionsstrukturdiagramms
9.2.3
Komponentendiagramm
................................................................................................... 303
9.2.4
Deployment-Diagramm
................................................................................................... 304
9.2.5
Objektdiagramm
................................................................................................... 305
9.2.6
Paketdiagramm
................................................................................................... 306
...........................................................................................................
307
Einf
ügen von Paketdiagrammelementen
Generieren von Paketdiagrammen beim Imp ortieren von
...........................................................................................................
309
Code
oder Binärdateien
9.2.7
Profildiagramm
...................................................................................................
und Stereotype
312
Hinzuf ügen von Stereoty p en und Def inieren von
...........................................................................................................
314
Eigenschaf
tswerten
...........................................................................................................
318
Stereoty
p e und Enumerationen
...........................................................................................................
320
Benutzerdef
inierte Stereoty p stile
...........................................................................................................
321
Benutzerdef
inierte Stereoty p sy mbole - Zuweisung
9.3
Zusätzliche
.................................................................................................................
Diagramme
326
9.3.1 XML-Schema-Diagramme
................................................................................................... 327
...........................................................................................................
328
Imp ortieren von XML-Schemas
...........................................................................................................
334
Einf
ügen von XML-Schema-Elementen
...........................................................................................................
337
Erstellen
und Generieren eines XML-Schemas
10 Austausch von Metadaten zwischen XMI und
XML
4
342
Altova UModel 2017
11 UModel-Unterstützung für die Arbeit im
Team
346
11.1 Erstellen
.................................................................................................................
und Bearbeiten von Unterprojektdateien
347
12 Versionskontrolle
354
12.1 Einrichten
.................................................................................................................
der Versionskontrolle
356
12.2 Unterstützte
.................................................................................................................
Versionskontrollsysteme
357
12.3 Versionskontrollbefehle
................................................................................................................. 359
12.3.1 Aus Versionskontrolle
...................................................................................................
öffnen
360
12.3.2 Versionskontrolle
...................................................................................................
aktivieren
363
12.3.3 Aktuellste
...................................................................................................
Version holen
364
12.3.4 Abrufen................................................................................................... 365
12.3.5 Ordner ...................................................................................................
abrufen
366
12.3.6 Auschecken
................................................................................................... 367
12.3.7 Einchecken
................................................................................................... 369
12.3.8 Auschecken
...................................................................................................
rückgängig...
370
12.3.9 Zu Versionskontrolle
...................................................................................................
hinzufügen
371
12.3.10 Von Versionskontrolle
...................................................................................................
ausgliedern
374
12.3.11 Aus Versionskontrolle
...................................................................................................
freigeben
375
12.3.12 Verlauf...................................................................................................
anzeigen
376
12.3.13 Unterschiede
...................................................................................................
anzeigen
378
12.3.14 Eigenschaften
...................................................................................................
anzeigen
380
12.3.15 Status aktualisieren
................................................................................................... 381
12.3.16 Versionskontrollmanager
................................................................................................... 382
12.3.17 Versionskontrolle
...................................................................................................
wechseln
383
12.4 Versionskontrolle
.................................................................................................................
mit Git
384
12.4.1 Aktivieren
...................................................................................................
der Git-Versionskontrolle mit dem Git SCC Plug-in
385
12.4.2 Hinzufügen
...................................................................................................
eines Projekts zur Git-Versionskontrolle
386
12.4.3 Klonen...................................................................................................
eines Projekts anhand der Git-Versionskontrolle
388
13 UModel Diagrammsymbole
392
13.1 Aktivitätsdiagramm
................................................................................................................. 393
13.2 Klassendiagramm
................................................................................................................. 394
13.3 Kommunikationsdiagramm
................................................................................................................. 395
13.4 Kompositionsstrukturdiagramm
................................................................................................................. 396
13.5 Komponentendiagramm
................................................................................................................. 397
Altova UModel 2017
5
13.6 Deployment-Diagramm
................................................................................................................. 398
13.7 Interaktionsübersichtsdiagramm
................................................................................................................. 399
13.8 Objektdiagramm
................................................................................................................. 400
13.9 Paketdiagramm
................................................................................................................. 401
13.10 Profildiagramm
................................................................................................................. 402
13.11 Protokoll-Zustandsdiagramm
................................................................................................................. 403
13.12 Sequenzdiagramm
................................................................................................................. 404
13.13 Zustandsdiagramm
................................................................................................................. 405
13.14 Zeitverlaufsdiagramm
................................................................................................................. 406
13.15 Use Case-Diagramm
................................................................................................................. 407
13.16 XML-Schema-Diagramm
................................................................................................................. 408
14 Menüreferenz
410
14.1 Datei ................................................................................................................. 411
14.2 Bearbeiten
................................................................................................................. 416
14.3 Projekt................................................................................................................. 419
14.4 Layout................................................................................................................. 426
14.5 Ansicht................................................................................................................. 427
14.6 Extras ................................................................................................................. 428
14.6.1 Benutzerdefinierte
...................................................................................................
Tools
429
14.6.2 Anpassen...
................................................................................................... 430
430
Bef...........................................................................................................
ehle
430
Sy...........................................................................................................
mbolleisten
........................................................................................................... 431
Extras
........................................................................................................... 434
Tastatur
........................................................................................................... 434
Menü
435
Op...........................................................................................................
tionen
14.6.3 Symbolleisten
...................................................................................................
und Fenster wiederherstellen
436
14.6.4 Optionen
................................................................................................... 437
14.7 Fenster................................................................................................................. 443
14.8 Hilfe ................................................................................................................. 444
15 Code Generator
450
15.1 SPL (Spy
.................................................................................................................
Programming Language)
451
15.1.1 Grundlegende
...................................................................................................
SPL-Struktur
452
15.1.2 Variablen
................................................................................................... 453
15.1.3 Operatoren
................................................................................................... 460
6
Altova UModel 2017
15.1.4
15.1.5
15.1.6
Bedingungen
................................................................................................... 461
Collections
...................................................................................................
und foreach
462
Subroutinen
................................................................................................... 464
...........................................................................................................
464
Deklaration einer Subroutine
...........................................................................................................
465
Subroutinenauf
ruf
15.2 Fehlercodes
................................................................................................................. 466
16 Lizenzinformationen
468
16.1 Electronic
.................................................................................................................
Software Distribution
469
16.2 Software-Aktivierung
.................................................................................................................
und Lizenzüberwachung
470
16.3 Rechte.................................................................................................................
am geistigen Eigentum
472
16.4 Altova .................................................................................................................
Endbenutzer-Lizenzvereinbarung
473
Index
Altova UModel 2017
7
Kapitel 1
UModel
UModel
1
3
UModel
UModel®2017 Basic Edition ist eine erschwingliche Modellierapplikation mit visueller
Benutzeroberfläche und zahlreichen, benutzerfreundlichen Funktionen, mit denen das Erlernen
von UML kein Problem mehr ist. UModel bietet viele hochspezifische Funktionen für die
Implementierung der nützlichsten Aspekte der UML 2.4 Spezifikation. UModel ist eine 32/64-Bit
Windows-Applikation, die auf Windows Server 2003/2008/2012, Windows XP, Windows Vista,
Windows 7, Windows 8 und Windows 10 läuft. Die 64-Bit-Version steht für die Enterprise und
Professional Version zur Verfügung.
UModel® 2017 unterstützt:
alle 14 UML 2.3 Modellierungsdiagramme
MDA (Model Driven Architecture)-Unterstützung, wodurch die Konvertierung zwischen
verschiedenen Programmiersprachen möglich wird (nur Enterprise Edition)
Import und Export von SQL-Datenbanken in UModel (nur Enterprise/Professional Edition)
Funktionen für die Arbeit im Team - gleichzeitige Projektbearbeitung
3-Weg-Projektzusammenführung
Protokoll-Zustandsdiagramme
SysML-1.2-Diagramme (nur Enterprise/Professional Edition)
Sequenzdiagrammgenerierung direkt anhand von Quellcode
Codegenerierung anhand von Zustandsdiagrammen (nur Enterprise Edition)
UModel API und Plug-in (nur Enterprise/Professional Edition)
Integrierte Skripting-Umgebung und Formulareditor (nur Enterprise/Professional Edition)
Visual Studio Integration (nur Enterprise/Professional Edition)
Eclipse Integration (nur Enterprise/Professional Edition)
Unterstützung für Versionskontrollsysteme
XML-Schema-Diagramme
Business Process Modeling Notation 1.0 und 2.0 (nur Enterprise/Professional Edition)
mehrere Ebenen bei UML-Diagrammen (nur Enterprise/Professional Edition)
Import von Java-, C#- und Visual Basic-Binärdateien
Verknüpfen von Diagrammen und Modellierungselementen mittels Hyperlinks
Syntaxfärbung in Diagrammen
Cascading Styles
unbegrenztes Rückgängigmachen und Wiederherstellen
Generierung von Java-, C#- und Visual Basic-Code anhand von Modellen
Reverse Engineering von vorhandenem Java-, C#- und Visual Basic-Quellcode
vollständiges Round-Trip Engineering mit Zusammenführung von Code und Modell
XMI-Version 2.4 für UML 2.0, 2.1und 2.1.2, 2.2, 2.3, 2.4-Modellimport und -export
Generierung von UModel Projektdokumentation
Dank dieser Funktionen können Entwickler - selbst Neulinge im Bereich der SoftwareModellierung - rasch das volle Potenzial von UML ausschöpfen, um produktiver arbeiten und
optimale Ergebnisse erzielen zu können.
© 2016 Altova GmbH
Altova UModel 2017
4
UModel
UML®, OMG™, Object Management Group™ und Unified Modeling Language™ sind entweder
eingetragene Markenzeichen oder Markenzeichen der Object Management Group, Inc. in den
USA und/oder anderen Ländern.
Letzte Aktualisierung: 28.11.2016
Altova UModel 2017
© 2016 Altova GmbH
Kapitel 2
6
2
Altova Web site:
Einführung in Altova UModel
UML (Unified Modeling Language) ist eine vollständige Modelliersprache, die jedoch nicht
vorschreibt, welche Methode bei der Entwicklung, Code Generierung und beim Round-Trip
Engineering verwendet werden soll. UModel wurde so konzipiert, dass der Benutzer bei der
Modellierung vollkommen freie Hand hat:
UModel Diagramme können jederzeit und in jeder Reihenfolge erstellt werden; es muss
bei der Modellierung keine vorgeschriebene Reihenfolge eingehalten werden.
Code oder Modelle können auf Ebene eine Projekts, Pakets oder sogar einer Klasse
zusammengeführt werden. Bei UModel müssen kein Pseudocode oder Kommentare im
generierten Code vorhanden sein, damit ein Round-Trip Engineering durchgeführt werden
kann.
Die Codegenerierung in UModel basiert auf SPL- (Spy Programming Language) Vorlagen
und kann komplett angepasst werden. Änderungen werden automatisch bei der
Codegenerierung erkannt.
Bei der Codegenerierung und dem Reverse Engineering werden derzeit die folgenden
Sprachen unterstützt:
Sprache
Version
C#
1.2, 2.0, 3.0, 4.0, 5.0, 6.0
Java
1.4, 5.0 (1.5), 6, 7, 8
Visual Basic .NET
7.1, 8.0, 9.0
Ein einziges Projekt kann gleichzeitig sowohl Java-, C#- oder VB.NET-Code unterstützen.
Unterstützung für UML-Vorlagen und Generics.
XML-Metadaten-Austausch (XMI 2.1 für UML 22.0, 2.1.2, 2.2, 2.3 und XMI 2.4 für UML
2.4.1)
Beim Hinzufügen von Eigenschaften oder Operationen bietet UModel Eingabehilfen zur
Auswahl von Typen, Spezialisierung und Klassifizierung und anderen Eigenschaften, die
auch in gängigen IDEs wie XMLSpy, Visual Studio oder Eclipse zur Verfügung stehen.
Dank der Syntaxfärbung in Diagrammen werden UML-Diagramme attraktiver und intuitiver.
Die Modellierungselemente und ihre Eigenschaften (Schriftart, Farben, Umrandungen
usw.) können auf Ebene von Projekten, Knoten/Zeilen, Elementfamilien und Elementen
hierarchisch vollständig angepasst werden.
In Use-Case-Diagrammen können anpassbare Akteure definiert werden, mit denen
Terminals oder andere Symbole dargestellt werden.
Modellierungselemente können auf dem Diagrammregister, im Modell-Struktur-Fenster,
im Meldungsfenster und im Fenster "Dokumentation" nach Namen durchsucht werden.
Klassen oder Objektassoziationen, Abhängigkeiten, Generalisierungen usw. können in
Modeldiagrammen über das Kontextmenü gefunden/markiert werden.
Die Funktion zum unbegrenzten Rückgängigmachen und Wiederherstellen hält nicht nur
Änderungen am Inhalt fest, sondern auch alle Änderungen am Stil von Modellelementen.
Bitte beachten Sie:
Altova UModel 2017
© 2016 Altova GmbH
7
Dieses Dokument enthält keine Beschreibung oder Erläuterung von UML (Unified
Modeling Language); vielmehr wird darin beschrieben, wie die UModel
Modellierungsapplikation verwendet wird und wie Code modelliert sowie ein Round-Trip
Engineering durchgeführt wird.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 3
UModel Tutorial
10
UModel Tutorial
3
UModel Tutorial
In diesem Tutorial wird der Reihe nach beschrieben, wie man im Allgemeinen beim Erstellen eines
Modellierungsprojekts in UModel vorgeht.
Der Großteil des Tutorials ist dem Forward Engineering gewidmet, d.h. dem Erstellen von UMLDiagrammen in UModel und dem Generieren von Code. Anschließend wird auf das Round-Trip
Engineering eingegangen. In den Abschnitten über Round-Trip Engineering wird der Vorgang
sowohl von der Code-Seite als auch von der Modellseite aus beschrieben.
Im Tutorial werden die folgenden UML-Diagramme beschrieben und wie die verschiedenen
Modellierungselemente darin verwendet werden. Es werden die folgenden Diagramme und die
damit in Zusammenhang stehenden Vorgänge beschrieben:
Forward Engineering:
Use Cases (Anwendungsfälle)
Klassendiagramme
Objektdiagramme
Deployment-Diagramme (Verteilungsdiagramme)
Round-Trip Engineering (Modell - Code - Modell)
Codegenerierung von UModel
Hinzufügen einer neuen Operation zum externen Code
Überführen des externen Codes in UModel.
Round-Trip Engineering (Code - Modell - Code)
Importieren von mit XMLSpy erzeugtem Code aus einem Verzeichnis (oder einer
Projektdatei)
Hinzufügen einer neuen Klasse zum generierten Modell in UModel
Zusammenführen des aktualisierten Projekts mit dem externen Code.
Alle in diesem Tutorial verwendeten Beispiele stehen anfangs im Ordner C:\Documents and
Settings\All Users\Application Data\Altova zur Verfügung. Wenn ein Einzelbenutzer die
Applikation zum ersten Mal startet, werden die Beispieldateien für diesen Ordner in den Ordner
C:\Documents and Settings\<username>\My Documents\Altova\UModel2017
\UModelExamples\ kopiert. Verschieben, bearbeiten oder löschen Sie daher die Beispieldateien
im Anfangsverzeichnis ...\All Users\.... nicht.
BankView-start.ump
ist die UModel-Projektdatei, in der sich die Tutorial-Beispieldatei im Anfangszustand
befindet. In dieser Phase enthält sie einige Modell-Diagramme sowie Klassen, Objekte
und andere Modellelemente. Während Sie das Tutorial durcharbeiten, werden nach und
nach neue Pakete, Modelldiagramme und viele andere Elemente hinzugefügt, um Ihnen
zu demonstrieren, wie leicht Sie mit UModel Applikationen modellieren können. Beachten
Sie bitte, dass die Syntaxüberprüfung bei dieser Datei Fehler und Warnmeldungen
ausgibt. Im Tutorial wird beschrieben, wie Sie diese Probleme beheben können.
BankView-finish.ump
ist die UModel Projektdatei, in der Sie das Tutorial-Beispiel im Endzustand sehen. Diese
Projektdatei wird beim Generieren von Code und beim Synchronisieren des Codes mit
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
11
UModel verwendet.
Der OrgChart.zip-Ordner in diesem Ordner wird für das Round-Trip Engineering
verwendet. Entpacken Sie den Ordner bitte in den Ordner ..\UmodelExamples, bevor Sie
mit dem Abschnitt beginnen.
Weitere Beispieldateien sowohl für die Programmiersprache Java als auch C# liegen ebenfalls im
selben Verzeichnis: Bank_Java.ump, Bank_CSharp.ump und Bank_MultiLanguage.ump.
Diese Projektdateien enthalten auch Sequenzdiagramme, die weiter hinten in dieser
Dokumentation beschrieben sind.
Im Abschnitt "Projekte und Code Engineering" finden Sie eine Anleitung, wie man ein Projekt von
Grund auf neu erstellt und Code generiert.
© 2016 Altova GmbH
Altova UModel 2017
12
UModel Tutorial
3.1
Starten von UModel
Starten von UModel
Nachdem Sie UModel auf Ihrem Computer installiert haben:
1. Starten Sie UModel mit einem Doppelklick auf das UModel-Symbol auf Ihrem Desktop
oder rufen Sie UModel über Start | Programme auf.
UModel wird gestartet, wobei das Standardprojekt "NeuesProjekt1" angezeigt wird.
Beachten Sie die Hauptbereiche der Benutzeroberfläche: die drei Fenster auf der linken
Seite und das leere Diagrammfenster auf der rechten Seite.
Auf dem Register "Modell-Struktur" werden zwei Standardpakete angezeigt: "Root" und
"Component View". Diese beiden Pakete können in einem Projekt nicht gelöscht oder
umbenannt werden.
So öffnen Sie das Projekt BankView-start:
1. Wählen Sie die Menüoption Datei | Öffnen und navigieren Sie zum UModel-Ordner ...
\UModelExamples\Tutorial. Beachten Sie, dass Sie eine UMP-Datei auch über eine
URL öffnen können. Nähere Informationen finden Sie unter Zu URL wechseln.
2. Öffnen Sie die Projektdatei BankView-start.ump.
Die Projektdatei wird nun in UModel geladen. Unter dem Root-Paket sehen Sie nun einige
vordefinierte Pakete. Beachten Sie, dass das Hauptfenster zu diesem Zeitpunkt leer ist.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Starten von UModel
13
Das Modell-Struktur-Fenster bietet verschiedene Ansichten Ihres Modellierungsprojekts:
Auf dem Register Modell-Struktur werden alle Modellierungselemente Ihres UModelProjekts angezeigt. Elemente können auf diesem Register mit Hilfe der StandardBearbeitungstasten sowie Drag and Drop direkt manipuliert werden.
Auf dem Register Diagramm-Struktur haben Sie schnellen Zugriff auf die
Modellierungsdiagramme Ihres Projekts, egal an welcher Stelle in der Projektstruktur sich
diese befinden. Diagramme werden nach Diagrammtyp gruppiert.
Das Register Favoriten ist eine konfigurierbare Ablage für Modellierungselemente. Mit
dem Kontextmenü-Befehl "Zu Favoriten hinzufügen" können Sie jede Art von
Modellierungselement auf dieses Register platzieren.
Das Fenster "Eigenschaften" bietet zwei Ansichten bestimmter Modelleigenschaften:
Auf dem Register Eigenschaften sehen Sie die Eigenschaften des aktuell ausgewählten
Elements aus dem Fenster "Modell-Struktur" oder "Diagramm". Auf diesem Register
können Elementeigenschaften definiert oder aktualisiert werden.
Auf dem Register Stile sehen Sie Attribute von Diagrammen oder Elementen, die in der
Diagrammansicht angezeigt werden. Diese Stilattribute lassen sich in zwei allgemeine
© 2016 Altova GmbH
Altova UModel 2017
14
UModel Tutorial
Starten von UModel
Gruppen unterteilen: Formatierungen und Anzeigeeinstellungen.
Auf dem Register Hierarchie sehen Sie alle Beziehungen des aktuell ausgewählten
Modellierungselements in zwei unterschiedlichen Ansichten. Das Modellierungselement
kann in einem Modellierungsdiagramm, der Modell-Struktur oder auf dem Register
"Favoriten" ausgewählt werden.
Im Übersichtsfenster werden mehrere Register angezeigt:
Das Register Übersicht, auf dem das aktive Diagramm im Umriss dargestellt ist.
Das Register Dokumentation, auf dem Sie Ihre Klassen nach Klassen dokumentieren
können.
Darstellung der Modellelemente in der Modell-Struktur
Pakettypen:
UML-Paket
Java Namespace Root-Paket
C# Namespace Root-Paket
Visual Basic Root-Paket
XML-Schema Root-Paket
Java-, C#-, VB-Codepaket (Paketdeklarationen werden erstellt, wenn der Code generiert wird)
Diagrammtypen:
Aktivitätsdiagramm
Klassendiagramm
Komponentendiagramm
Deployment-Diagramm
Objektdiagramm
Paketdiagramm
Profildiagramm
Sequenzdiagramm
Zustandsdiagramm
Use Case-Diagramm
XML-Schema-Diagramm
Business Process Modeling
Notation
Elementtypen:
Ein Element, das im aktiven Diagramm gerade sichtbar ist, wird mit einem blauen Punkt am
unteren Rand dargestellt. In diesem Fall handelt es sich um ein Klassenelement.
Klasseninstanz/-objekt
Klasseninstanz-Slot
Klasse
Eigenschaft
Operation
Parameter
Akteur (sichtbar im aktiven Use Case-Diagramm)
Use Case
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Starten von UModel
15
Komponente
Knoten
Artefakt
Schnittstelle
Beziehungen (/Paket)
Einschränkungen
© 2016 Altova GmbH
Altova UModel 2017
16
UModel Tutorial
3.2
Use Cases
Altova Website:
Use Cases
UML Use Case-Diagramme
Ziel dieses Tutorial-Abschnitt ist es:
ein neues Paket zum Projekt hinzuzufügen
ein neues Use Case-Diagramm zum Projekt hinzuzufügen
Use Case-Elemente zum Diagramm hinzuzufügen und die Abhängigkeiten zwischen den
Elementen zu definieren
Elemente auf dem Diagramm-Register auszurichten und deren Größe anzupassen.
So fügen Sie ein neues Paket zu einem Projekt hinzu:
1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf das Root-Paket und wählen
Sie Neues Element | Paket.
2. Geben Sie den Namen des neuen Pakets ein, z.B. Use Case View und drücken Sie die
Eingabetaste.
Nähere Informationen zu Paketen und ihren Eigenschaften finden Sie unter "Pakete".
So fügen Sie ein Diagramm zu einem Paket hinzu:
1. Rechtsklicken Sie auf das zuvor erstellte Paket "Use Case View".
2. Wählen Sie den Befehl Neues Diagramm | UseCase-Diagramm.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Use Cases
17
Dem Paket wurde nun in der Modell-Struktur-Ansicht ein Use Case-Diagramm
hinzugefügt und im Diagramm-Fenster wurde ein Diagramm-Register angelegt, das
automatisch einen Standardnamen erhielt.
3. Doppelklicken Sie auf dem Register "Modell-Struktur" auf diesen Namen, ändern Sie ihn
in "Overview Account Balance" und drücken Sie die Eingabetaste.
Nähere Informationen zu Diagrammen und deren Eigenschaften finden Sie unter
Diagramme.
So fügen Sie Use Case-Elemente zum Use Case-Diagramm hinzu:
1. Rechtsklicken Sie in das neu erstellte Diagramm und wählen Sie Neu | Akteur.
Das Akteurelement wird an der Mausposition eingefügt.
2. Klicken Sie auf das Use Case-Symbol
in der Symbolleiste und dann in das
Diagrammfenster, um das Element einzufügen.
Es wird ein Element "UseCase1" eingefügt. Beachten Sie, dass das Element und sein
Name aktuell ausgewählt sind und dass seine Eigenschaften auf dem Register
"Eigenschaften" angezeigt werden.
© 2016 Altova GmbH
Altova UModel 2017
18
UModel Tutorial
Use Cases
3. Ändern Sie den Titel in "get account balance" und drücken Sie zur Bestätigung die
Eingabetaste. Doppelklicken Sie auf den Titel, wenn er nicht aktiv ist.
Beachten Sie, dass die Größe des Use Case automatisch an die Textlänge angepasst
wird.
Modellelemente haben verschiedene Verbindungsziehpunkte und andere Elemente, mit
denen Sie diese bearbeiten können.
Anmerkung: Durch Drücken von Strg + Eingabetaste können Sie einen mehrzeiligen Use
Case-Namen erstellen.
Bearbeiten von UModel Elementen: Ziehpunkte und Bereiche
1. Doppelklicken Sie auf den Text "Akteur1" des Akteur-Elements, ändern Sie den Namen
in "Standard User" und drücken Sie zur Bestätigung die Eingabetaste.
2. Platzieren Sie den Mauszeiger über den "Ziehpunkt" rechts vom Akteur.
Es erscheint ein Tooltip mit dem Inhalt "Assoziation".
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Use Cases
19
3. Klicken Sie auf den Ziehpunkt, ziehen Sie die Assoziationslinie nach rechts auf den
Anwendungsfall (Use case) "get account balance".
Zwischen Dem Akteur und dem Anwendungsfall wurde nun eine Assoziation erstellt. Die
Eigenschaften der Assoziation sind auch auf dem Register "Eigenschaften" zu sehen.
Die neue Assoziation wurde unter dem Element "Beziehungen" des Use Case ViewPakets hinzugefügt.
4. Klicken Sie auf den Anwendungsfall (Use Case) und ziehen Sie ihn nach rechts, um ihn
neu zu positionieren.
Die Eigenschaften der Assoziation sind auf dem Assoziationsobjekt zu sehen.
5. Klicken Sie auf den Anwendungsfall, um ihn auszuwählen und anschließend auf das
Symbol zum Reduzieren am linken Rand der Use Case-Ellipse.
Der Bereich "extension points" wird nun ausgeblendet.
© 2016 Altova GmbH
Altova UModel 2017
20
UModel Tutorial
Use Cases
Bitte beachten Sie:
Ein blauer Punkt neben einem Elementsymbol
auf dem Register
"Modell-Struktur" bedeutet, dass das Element auf dem aktuellen Diagrammregister
sichtbar ist. Wenn Sie die Größe des Akteurs anpassen, wird auch das Textfeld
angepasst, das auch mehrere Zeilen enthalten kann. Mit Strg + Eingabetaste wird eine
Zeilenschaltung in den Text eingefügt.
Fertigstellen des Use Case-Diagramms:
Gehen Sie vor, wie oben beschrieben und:
1. Klicken Sie in der Symbolleiste auf das Use Case-Symbol und halten Sie gleichzeitig
die Strg-Taste gedrückt.
2. Klicken Sie auf dem Diagrammregister an zwei verschiedenen Stellen vertikal
übereinander in das Register, um zwei weitere Use Cases hinzuzufügen. Lassen Sie
anschließend die Strg-Taste los.
3. Geben Sie dem ersten Use Case den Namen "get account balance sum" und dem
zweiten den Namen, "generate monthly revenue report".
4. Klicken Sie auf das Einklappsymbol der einzelnen Use Case-Ellipsen um den extensionBereich auszublenden.
5. Klicken Sie auf den Akteur und erstellen Sie mit Hilfe des Assoziationsziehpunkts eine
Assoziation zwischen "Standard User" und "get account balance sum".
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Use Cases
21
So erstellen Sie eine "include"-Abhängigkeit zwischen Use Cases (und somit einen
untergeordneten Use Case):
1. Klicken Sie auf den Include-Ziehpunkt der "get account balance sum" Use Case-Ellipse
(unter der Ellipse) und ziehen Sie die Abhängigkeit auf "get account balance".
Es wird eine "include"-Abhängigkeit erstellt und auf dem strichlierten Pfeil wird das
include-Stereotyp angezeigt.
Einfügen von benutzerdefinierten Akteuren:
Beim Akteur im Use Case "generate monthly revenue report" handelt es sich nicht um eine
Person, sondern um einen automatisierten Batch-Auftrag, der von einem Bankcomputer
ausgeführt wird.
1. Fügen Sie mit Hilfe des Symbolleistensymbols "Akteur" einen Akteur in das Diagramm
ein.
2. Benennen Sie den Akteur in "Bank" um.
3. Platzieren Sie den Cursor über das Register "Eigenschaften" und klicken Sie auf das
Durchsuchen-Symbol
neben dem Eintrag "Symboldateiname".
4. Klicken Sie auf die Schaltfläche, um die benutzerdefinierte Bitmap-Grafik Bank-PC.bmp
auszuwählen.
5. Deaktivieren Sie das Kontrollkästchen "Absoluter Pfad", um den Pfad relativ zu machen.
© 2016 Altova GmbH
Altova UModel 2017
22
UModel Tutorial
Use Cases
Bei Auswahl von "Vorschau" wird im Dialogfeld eine Vorschau der ausgewählten Datei
angezeigt.
6. Klicken Sie auf OK, um die Einstellungen zu bestätigen und fügen Sie den neuen Akteur
ein.
7. Verschieben Sie den neuen Akteur "Bank" und platzieren Sie ihn rechts vom untersten
Use Case.
8. Klicken Sie in der Symbolleiste auf das Symbol "Assoziation"
und ziehen Sie es
vom Akteur "Bank" zum Use Case "generate monthly revenue report".
Dies ist eine alternative Methode zum Erstellen einer Assoziation.
Bitte beachten Sie:
Die Hintergrundfarbe, mit der die Bitmap-Grafik transparent gemacht werden kann, hat die
RGB-Werte 82.82.82.
Ziehen von Elementen - Ausrichtungshilfslinien
Wenn Sie Komponenten in einem Diagramm mit der Maus ziehen, erscheinen Hilfslinien, an
denen Sie ein Element an jedem anderen Element im Diagramm ausrichten können. Diese Option
kann mit Hilfe der Menüoption Extras | Optionen | Ansicht - Gruppe "Ausrichtung" "Hilfslinien
aktivieren" aktiviert bzw. deaktiviert werden.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Use Cases
23
Ausrichten und Anpassen der Größe von Elementen:
1. Ziehen Sie einen Auswahlrahmen auf, indem Sie auf dem Diagrammhintergrund ein
Rechteck aufziehen, in dem von oben angefangen alle drei Use Cases enthalten sind.
Beachten Sie, das die Umrandung des zuletzt markierten Use Case im Diagramm und im
Übersichtsfenster strichliert angezeigt wird.
Alle Use Cases sind nun ausgewählt, wobei die unterste Ellipse die Basis für die
folgenden Anpassungen bildet.
2. Klicken Sie in der Titelleiste auf das Symbol "Größe angleichen"
.
Die Use Case-Elemente werden alle zentriert und erhalten dieselbe Größe.
3. Klicken Sie auf das Symbol "Horizontal zentrieren"
auszurichten.
© 2016 Altova GmbH
, um alle Ellipsen parallel
Altova UModel 2017
24
UModel Tutorial
Use Cases
Bitte beachten Sie:
Sie können auch mit Hilfe der Strg-Taste mehrere Elemente auswählen.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
3.3
Klassendiagramme
25
Klassendiagramme
Altova Website:
UML-Klassendiagramme
Ziel dieses Tutorial-Abschnitts ist es:
eine neue abstrakte Klasse mit dem Namen "Account" sowie Attribute und Operationen
hinzuzufügen
eine Kompositions-Assoziation von Bank zu Account zu erstellen
So öffnen Sie ein anderes Diagramm in UModel:
1. Klicken Sie auf das Register "Diagramm-Struktur".
2. Erweitern Sie das Paket "Klassendiagramme", um dessen Inhalt zu sehen.
Es werden nun alle im Projekt vorhandenen Klassendiagramme angezeigt.
3. Doppelklicken Sie auf das Diagrammsymbol
BankView Main.
Das Klassendiagramm wird in Form eines Registers im Arbeitsbereich angezeigt.
Bitte beachten Sie:
Sie können natürlich auch auf dem Register "Modell-Struktur" auf das
Klassendiagrammsymbol unterhalb des Pakets "BankView" doppelklicken, um dasselbe
Ergebnis zu erzielen.
Im Klassendiagramm sehen Sie zwei konkrete Klassen, die durch eine Kompositions-Assoziation
verbunden sind.
© 2016 Altova GmbH
Altova UModel 2017
26
UModel Tutorial
Klassendiagramme
So fügen Sie eine neue Klasse hinzu und definieren sie als abstrakt:
1. Klicken Sie in der Symbolleiste auf das Klassensymbol
und anschließend rechts
von der Klasse "Bank" um die Klasse einzufügen.
2. Ändern Sie den Namen "Klasse1" z.B. in "Account" und drücken Sie zum Bestätigen die
Eingabetaste, (doppelklicken Sie auf den Namen, wenn er nicht mehr aktiv ist).
Beachten Sie, dass die Eigenschaften der aktuellen Klasse auf dem Register
"Eigenschaften" angezeigt werden.
3. Aktivieren Sie im Bereich "Eigenschaften" das Kontrollkästchen "abstrakt", um die
Klasse abstrakt zu machen.
4. Klicken Sie in das Textfeld von "Codedateiname" und geben Sie Account.java ein, um
den Dateinamen der Java-Klasse zu definieren.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Klassendiagramme
27
Der Name der Klasse wird nun kursiv angezeigt, da abstrakte Klassen kursiv angezeigt
werden.
So fügen Sie Eigenschaften zu einer Klasse hinzu:
1. Rechtsklicken Sie auf die Klasse "Account" und wählen Sie Neu | Eigenschaft oder
drücken Sie F7.
Es wird eine Standardeigenschaft "Eigenschaft1" mit Stereotypmarkierungen << >>
eingefügt.
2. Geben Sie den Eigenschaftsnamen "balance" ein und fügen Sie anschließend einen
Doppelpunkt ":" hinzu.
Es erscheint eine Dropdown-Liste mit allen gültigen Typen.
3. Geben Sie das Zeichen "f" ein und drücken Sie die Eingabetaste, um den RückgabewertDatentyp "float" einzufügen.
Beachten Sie bitte, dass die Groß- und Kleinschreibung in Dropdown-Listen eine Rolle
spielt!
© 2016 Altova GmbH
Altova UModel 2017
28
UModel Tutorial
Klassendiagramme
4. Fahren Sie in derselben Zeile fort, indem Sie "=0" anhängen, um den Standardwert zu
definieren.
5. Drücken Sie die Taste F7, um eine zweite Eigenschaft zur Klasse hinzuzufügen.
6. Geben Sie Id: ein und wählen Sie aus der Dropdown-Liste den Eintrag String aus.
So fügen Sie Operationen zu einer Klasse hinzu:
1. Rechtsklicken Sie auf die Klasse "Account" und wählen Sie Neu | Operation oder
drücken Sie die Taste F8.
2. Geben Sie als Konstruktor Account() ein.
Gehen Sie vor wie oben beschrieben und:
3. Fügen Sie zwei weitere Operationen hinzu, und zwar getBalance:float und
getId:String.
Verwenden Sie die Autokomplettierungsfunktion bei Definieren der Operationen und:
4. Erstellen Sie durch Drücken der Taste F8 eine weitere Operation collectAccountInfo
und drücken Sie die Klammer-auf-Taste "(".
Wenn Sie das Zeichen "i" eingeben, wird die Dropdown-Liste geöffnet und Sie können
einen der Operationsrichtungsparameter auswählen: in, in / out, oder out.
5. Wählen Sie aus der Dropdown-Liste "in" aus, geben Sie ein Leerzeichen ein und fahren
Sie in derselben Zeile fort.
6 Geben Sie "bankAPI" ein, gefolgt von einem Doppelpunkt.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Klassendiagramme
29
7. Wählen Sie aus der Dropdown-Liste IBankAPI aus, fügen Sie die schließende Klammer
")" hinzu und geben Sie einen Doppelpunkt ":" ein.
8. Drücken Sie die Taste "b", um den Booleschen Datentyp auszuwählen und fügen Sie ihn
anschließend durch Drücken der Eingabetaste ein.
9. Drücken Sie die Eingabetaste, um die Definition zu beenden.
Bitte beachten Sie:
Wenn Sie auf das Ein-/Ausblendsymbol links von einer Operation
oder Eigenschaft
klicken, wird eine Dropdown-Liste geöffnet, über die Sie den Sichtbarkeitsstatus
ändern können. Beachten Sie, dass diese Ein-/Ausblendsymbole in die UML-konformen
Symbole geändert werden können.
Löschen von Klasseneigenschaften und Operationen aus einem Klassendiagramm:
1. Drücken Sie F8 und dann die Eingabetaste um eine Standardoperation "Operation1" zur
Klasse "Account" hinzuzufügen.
2. Klicken Sie auf Operation1 und drücken Sie die Entf-Taste, um die Operation zu löschen.
Es erscheint eine Meldung, in der Sie gefragt werden, ob das Element aus dem Projekt
gelöscht werden soll. Klicken Sie auf "Ja", um Operation1 aus der Klasse und dem
Projekt zu löschen.
Bitte beachten Sie:
Wenn Sie die Operation nur aus der Klasse im Diagramm löschen möchten, nicht aber
aus dem Projekt, drücken Sie Strg + Entf. Sie können auch eine Bestätigungsmeldung
© 2016 Altova GmbH
Altova UModel 2017
30
UModel Tutorial
Klassendiagramme
aktivieren, die Sie beim Löschen von Objekten bestätigen müssen. Nähere Informationen
dazu finden Sie unter Extras | Bearbeiten"
Suchen (Löschen) von Klasseneigenschaften und Optionen aus der Modell-Struktur:
Eigenschaften und Optionen können auch direkt aus der Modell-Struktur gelöscht werden. Dazu
müssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1" in die
Klasse "Account" eingefügt (drücken Sie zum Einfügen F8 und anschließend die Eingabetaste):
1. Rechtsklicken Sie in der Klasse "Account" auf Operation1.
2. Wählen Sie die Option "In Modell-Struktur auswählen" oder drücken Sie F4.
Der Eintrag Operation1 erscheint nun auf dem Register "Modell-Struktur" unter Account
markiert.
3. Drücken Sie die Entf-Taste, um die Operation aus der Klasse und dem Projekt zu
löschen!
Beachten Sie, dass Sie durch Drücken von F4 beinahe jedes Modellierungselement in der
Modell-Struktur finden können.
Bitte beachten Sie:
Sie können beim Anzeigen von Attributeigenschaften auch vom Fenster "Eigenschaften"
zur Modell-Struktur navigieren. Nähere Informationen dazu finden Sie in der
Benutzerreferenz unter Eigenschaften.
Erstellen einer Kompositions-Assoziation zwischen den Klassen "Bank" und "Account":
1. Klicken Sie in der Titelleiste auf das Symbol "Komposition"
und ziehen Sie es von
der Klasse Bank zur Klasse Account. Wenn eine Assoziation erstellt werden kann,
erscheint die Klasse markiert.
In der Klasse "Bank" wird eine neue Eigenschaft (Property1:Account) erstellt. Die
beiden Klassen werden durch einen Kompositions-Assoziationspfeil verbunden.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Klassendiagramme
31
2. Doppelklicken Sie in der Klasse "Bank" auf den neuen Eintrag Property1 und ändern Sie
ihn in "accounts". Stellen Sie sicher, dabei die Account-Typdefinition (angezeigt in
blaugrün) nicht gelöscht wird.
3. Drücken Sie die Ende-Taste, um den Textcursor an das Ende der Zeile zu platzieren
4. Geben Sie eine öffnende eckige Klammer "[" ein, wählen Sie in der Dropdown-Liste "*"
aus, um die Multiplizität zu definieren und drücken Sie zum Bestätigen die
Eingabetaste.
© 2016 Altova GmbH
Altova UModel 2017
32
UModel Tutorial
3.3.1
Erstellen von abgeleiteten Klassen
Klassendiagramme
Ziel dieses Tutorialabschnitts ist es:
Hinzufügen eines neuen Klassendiagramms namens "Account Hierarchy" zum Projekt
Einfügen bestehender Klassen und Erstellen einer Klasse "Savings account"
Erstellen von drei abgeleiteten Klassen der abstrakten Basisklasse "Account" mit Hilfe
von Generalisierungen
So erstellen Sie ein neues Klassendiagramm:
1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf das Paket "bankview" (unter
Design-phase | BankView | com | altova) und wählen Sie Neues Diagramm |
Klassendiagramm.
2. Doppelklicken Sie auf den neuen Eintrag Klassendiagramm1, benennen Sie ihn in
"Account Hierarchy" um und drücken Sie die Eingabetaste.
Im Arbeitsbereich wird nun das Register "Account Hierarchy" angezeigt.
Einfügen von bestehenden Klassen in ein Diagramm:
1. Klicken Sie im Paket bankview auf die Klasse Account (unter com | altova | bankview)
und
2. Ziehen Sie sie auf das Register "Account Hierarchy".
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Klassendiagramme
33
3. Klicken Sie auf die Klasse CheckingAccount (im selben Paket) und ziehen Sie diese
ebenfalls auf das Register.
4. Platzieren Sie die Klasse links unterhalb der Klasse "Account".
5. Fügen Sie auf dieselbe Art die Klasse CreditCardAccount ein. Platzieren Sie sie rechts
von der Klasse CheckingAccount.
Hinzufügen einer neuen Klasse:
1. Rechtsklicken Sie auf den Diagrammhintergrund (rechts von der Klasse "CreditAccount")
und wählen Sie Neu | Klasse.
Daraufhin wird automatisch eine neue Klasse zum richtigen Paket hinzugefügt, also zu
bankview, welches das aktuelle Klassendiagramm Account Hierarchy enthält.
2. Doppelklicken Sie auf den Klassennamen und ändern Sie ihn in SavingsAccount.
© 2016 Altova GmbH
Altova UModel 2017
34
UModel Tutorial
Klassendiagramme
3. Drücken Sie F7 und fügen Sie eine neue "Property" (Eigenschaft) hinzu.
4. Geben Sie "interestRate" gefolgt von einem Doppelpunkt ein und drücken Sie "f", um
den Datentyp "float" aus der Dropdown-Liste auszuwählen. Drücken Sie zweimal die
Eingabetaste, um den Eintrag auszuwählen und die Auswahl zu bestätigen.
5. Drücken Sie F8 und fügen Sie die Operation/den Konstruktor SavingsAccount() hinzu.
6. Fügen Sie auf dieselbe Weise mit F8 die Operation getMinimumBalance:float hinzu.
7. Klicken Sie auf dem Register "Eigenschaften" in das Textfeld "Codedateiname" und
geben Sie SavingsAccount.java ein, um die Java-Codeklasse zu definieren.
Wiederverwenden/Kopieren bestehender Eigenschaften/Operationen:
Eigenschaften und Operationen können direkt mit Hilfe von Drag & Drop oder den StandardTastenkombinationen von einer Klasse in die andere kopiert oder verschoben werden. Dies
funktioniert in folgenden Fällen:
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Klassendiagramme
35
innerhalb einer Klasse auf dem Diagramm-Register
zwischen verschiedenen Klassen auf dem Diagramm-Register
in der Modell-Struktur-Ansicht
zwischen verschiedenen UML-Diagrammen durch Ziehen der kopierten Daten auf ein
anderes Diagrammregister.
Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und Einfügen in
UModel Diagrammen.
1. Erweitern Sie die Klasse Account in der Modell-Struktur.
2. Rechtsklicken Sie auf die Operation collectAccountInfo und wählen Sie Kopieren.
3. Rechtsklicken Sie in der Modell-Struktur auf die Klasse SavingsAccount und wählen
Sie Einfügen.
Die Operation wird in die Klasse "SavingsAccount" kopiert, wobei diese Klasse
automatisch erweitert wird, um die neue Operation anzuzeigen.
Die neue Operation ist nun auch im Klassendiagramm in der Klasse "SavingsAccount" zu
sehen.
Bitte beachten Sie:
Sie können diese Ergebnisse in der Modell-Struktur sowohl mit Kopieren/Einfügen (Strg C
bzw. V) als auch mit Drag & Drop erzielen. Eventuell müssen Sie die Sortieroptionen
deaktivieren, um die Operation zwischen bestimmten Elementen platzieren zu können.
© 2016 Altova GmbH
Altova UModel 2017
36
UModel Tutorial
Klassendiagramme
Erstellen von abgeleiteten Klassen - Generalisierung/Spezialisierung:
Derzeit enthält das Klassendiagramm die abstrakte Klasse "Account" sowie drei spezifische
"Account"-Klassen. Wir wollen nun eine Generalisierungs-/Spezialisierungsbeziehung zwischen
"Account" und den spezifischen Klassen definieren oder erstellen, d.h. wir wollen drei abgeleitete
konkrete Klassen erstellen.
1. Klicken Sie in der Symbolleiste auf das Symbol "Generalisierung"
und halten Sie
die Strg-Taste gedrückt.
2. Ziehen Sie den Cursor von CreditCardAccount (der Klasse in der Mitte) in die Klasse
"Account".
3. Ziehen Sie die Pfeilspitze von der Klasse CheckingAccount auf die zuvor erstellte
Generalisierung.
4. Ziehen Sie die Pfeilspitz von der Klasse SavingsAccount auf die zuvor erstellte
Generalisierung: lassen Sie jetzt die Strg-Taste los.
5. Zwischen den drei Unterklassen und der Überklasse "Account" werden
Generalisierungspfeile erstellt.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
3.4
Objektdiagramme
37
Objektdiagramme
Altova Website:
UML-Objektdiagramme
Ziel dieses Tutorialabschnittes ist es:
zu zeigen, wie Klassen- und Objektdiagramme in einem Diagramm kombiniert werden
können, um einen Schnappschuss des Objekts zu einem bestimmten Zeitpunkt zu
erhalten.
Objekte/Instanzen zu erstellen und die Beziehungen zwischen diesen zu definieren
Assoziationen/Objektbeziehungen zu formatieren
reale Daten in Objekte/Instanzen einzugeben
So öffnen Sie das Objektdiagramm:
1. Doppelklicken Sie auf das Sample Accounts-Diagrammsymbol unter dem bankviewPaket (oder unter Objektdiagramme auf dem Register "Diagramm-Struktur").
Die Klasse "Bank" sowie zwei damit in Beziehung stehende Objekte/Instanzen werden
im Objektdiagramm angezeigt.
AltovaBank:Bank ist das Objekt/die Instanz der Klasse "Bank", während John's
checking: CheckingAccount eine Instanz der Klasse CheckingAccount ist.
Einfügen einer Klasse in ein Objektdiagramm:
Klicken Sie in der Modell-Struktur auf das Account-Klassensymbol
und
ziehen Sie es auf das Register "Sample Accounts".
Die zuvor im BankView Main-Diagramm definierte Kompositions-Assoziation wird
automatisch erstellt.
© 2016 Altova GmbH
Altova UModel 2017
38
UModel Tutorial
Objektdiagramme
So fügen Sie durch Auswählen des Typs ein neues Objekt/eine neue Instanz hinzu:
1. Klicken Sie in der Symbolleiste auf das Instanzspezifikation-Symbol
und klicken
Sie anschließend in der Diagramm-Struktur unterhalb des Objekts "John's Checking".
2. Ändern Sie den Namen der Instanz in John's Credit und drücken Sie die Eingabetaste.
Wenn die Instanz aktiv ist, werden alle ihre Eigenschaften auf dem Register
"Eigenschaften" angezeigt.
3. Klicken Sie auf das Dropdown-Listenfeld classifier und wählen Sie aus der Liste den
Eintrag CreditCardAccount aus.
Beachten Sie: Bei Rechtsklick auf eine Instanzspezifikation und Auswahl von
Knoteninhalt ein-/ausblenden können Sie den Inhalt von Objekten ein- oder
ausblenden.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Objektdiagramme
39
So fügen Sie ein neues Objekt in der Modell-Struktur-Ansicht hinzu (um es dann in ein
Diagramm einzufügen):
1. Rechtsklicken Sie in der Modell-Struktur-Ansicht auf das bankview-Paket und wählen
Sie Neues Element | Instanzspezifikation.
2. Ändern Sie den Standard-Objektnamen in John's Saving und drücken Sie zum
Bestätigen die Eingabetaste.
Das neue Objekt wird zum Paket hinzugefügt und entsprechend gereiht.
Während das Objekt weiterhin auf dem Register "Modell-Struktur" ausgewählt ist,
3. Klicken Sie auf dem Register Eigenschaften auf das Dropdownlistenfeld classifier und
wählen Sie SavingsAccount.
4. Ziehen Sie das Objekt/die Instanz "John's Saving" vom Register "Modell-Struktur" auf das
Register "Sample Accounts" und platzieren Sie es unterhalb von "John's credit".
© 2016 Altova GmbH
Altova UModel 2017
40
UModel Tutorial
Objektdiagramme
Erstellen von "Objektbeziehungen" zwischen Objekten:
Objektbeziehungen sind die Instanzen von Klassenassoziationen und beschreiben die
Assoziationen zwischen Objekten/Instanzen zu einem bestimmten Zeitpunkt.
1. Klicken Sie auf die bestehende Objektbeziehung (Assoziation) zwischen AltovaBank
und John's Checking.
2. Klicken Sie auf dem Register "Eigenschaften" auf das Dropdown-Listenfeld classifier und
wählen Sie den Eintrag Account - Bank.
Die Objektbeziehung ändert sich nun gemäß den Klassendefinitionen in eine
Kompositions-Assoziation.
3.
Klicken Sie in der Symbolleiste auf das Instanzspezifikation-Symbol
positionieren Sie den Cursor über die Klasse John's Credit.
Der Cursor wird nun als +-Symbol angezeigt.
und
4. Ziehen Sie den Cursor vom Objekt John's Credit zu AltovaBank, um die beiden Objekte
zu verknüpfen.
4. Ändern Sie den Typ der Objektbeziehung über das Dropdown-Listenfeld classifier auf
dem Register "Eigenschaften" in Account - Bank.
5. Erstellen Sie wie oben beschrieben eine Objektbeziehung zwischen John's Saving und
AltovaBank.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
Objektdiagramme
41
Bitte beachten Sie:
Änderungen, die in einem Klassendiagramm am Assoziationstyp vorgenommen werden,
werden nun automatisch im Objektdiagramm aktualisiert.
Formatieren von Assoziations-/Objektbeziehungslinien in einem Diagramm:
1. Klicken Sie auf die unterste Objektbeziehung im Diagramm, falls sie nicht aktiv ist, und
ziehen Sie den Eckkonnektor nach links.
Auf diese Art können Sie die Linie sowohl horizontal als auch vertikal verschieben.
Positionieren Sie auf diese Art Objektbeziehungen auf dem Diagrammregister neu.
Eingabe von Beispieldaten in Objekte:
Der Instanzwert eines Attributs/einer Eigenschaft in einem Objekt wird Slot genannt.
1.
2.
3.
Klicken Sie in die entsprechenden Slots der einzelnen Objekte und geben Sie
Beispieldaten ein.
Doppelklicken Sie z.B.. im Objekt John's Checking in den balance-Slot und geben Sie
als Kontostand 11,975.00 ein (englische Dezimalschreibweise).
Füllen Sie den Rest der Daten aus, um den Status der aktuellen Instanz zu sehen.
© 2016 Altova GmbH
Altova UModel 2017
42
UModel Tutorial
Altova UModel 2017
Objektdiagramme
© 2016 Altova GmbH
UModel Tutorial
3.5
43
Ziel dieses Tutorialabschnittes ist:
zu zeigen, wie Klassen in ein Komponentendiagramm eingefügt werden
Realisierungsbeziehungen zwischen den Klassen und der Komponente "BankView" zu
erstellen
zu zeigen, wie Zeileneigenschaften geändert werden
Komponenten in ein Komponentendiagramm einzufügen und Verwendungsbeziehungen
zu einer Schnittstelle zu erstellen
So öffnen Sie ein Komponentendiagramm:
1. Klicken Sie auf das Register "Diagramm-Struktur", erweitern Sie die Komponente
Komponentendiagramme und doppelklicken Sie auf das "BankView realization"Diagrammsymbol.
Daraufhin wird das Komponentendiagramm "BankView realization" angezeigt.
2. Wechseln Sie zurück zum Register "Modell-Struktur", indem Sie darauf klicken.
So fügen Sie (bestehende) Klassen in ein Komponentendiagramm ein:
1. Suchen Sie die Klasse SavingsAccount
unter dem bankviewPaket.
2. Ziehen Sie sie in das Komponentendiagramm.
Die Klasse wird mit allen ihren Bereichen angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
44
UModel Tutorial
3. Klicken Sie auf beide Einklappsymbole, bis nur mehr der Bereich mit dem Klassennamen
angezeigt wird.
4. Fügen Sie auf dieselbe Weise die abstrakte Klasse Account ein.
Bitte beachten Sie:
Das Paket, das die eingefügte Klasse enthält, wird im Namensbereich in der Form "from
bankview" angezeigt.
So erstellen Sie Realisierungsbeziehungen zwischen einer Klasse und einer
Komponente:
1. Klicken Sie in der Symbolleiste auf das Realisierungssymbol
.
2. Ziehen Sie den Pfeil von SavingsAccount auf die Komponente BankView.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
45
3. Klicken Sie auf den Ziehpunkt Komponentenrealisierung der Klasse "Account" (am
unteren Rand der Klasse) und ziehen Sie ihn auf die Komponente "BankView".
Sie können auf beide Arten Realisierungsbeziehungen erstellen. Es gibt noch eine
weitere Methode, mit der Sie nur in der Modell-Struktur Realisierungsbeziehungen
erstellen können. Nähere Informationen dazu finden Sie unter "Round-Trip Engineering
(Code - Modell - Code)".
Ändern von Linienmerkmalen (bei Realisierungen):
Wenn Sie in einem UModel-Diagramm auf eine Abhängigkeit oder eine andere Linienart klicken,
werden die Symbole zum Zeichnen von Linien in der Layout-Symbolleiste aktiviert.
1.
Klicken Sie auf die Realisierungslinie zwischen SavingsAccount und BankView.
2.
Klicken Sie in der Layout-Symbolleiste auf das Linienart-Symbol Gerade Linie
.
Die Linieneigenschaften werden sofort geändert. Entlang der Linien werden kleine
© 2016 Altova GmbH
Altova UModel 2017
46
UModel Tutorial
Symbole, so genannte Wegpunkte angezeigt. Sie können darauf klicken und sie
verschieben, um Linienmerkmale zu ändern. Ändern Sie die Linieneigenschaften Ihren
Wünschen entsprechend.
Einfügen von Komponenten und Erstellen von Verwendungsbeziehungen:
1. Doppelklicken Sie in der Modell-Struktur auf das Overview-Diagrammsymbol direkt
unterhalb des Design-phase-Pakets.
Daraufhin wird das Komponentendiagramm "Overview" geöffnet. Darin werden die aktuell
definierten Systembeziehungen zwischen Komponenten und Schnittstellen angezeigt.
2. Klicken Sie in der Modell-Struktur auf die BankView GUI-Komponente unterhalb des
Component View | BankView-Pakets und ziehen Sie sie auf das Diagrammregister
Overview.
Das Paket, das die eingefügte Komponente enthält, wird im Namensbereich "from
BankView" angezeigt.
3. Fügen Sie auf dieselbe Art die BankView-Komponente unter demselben Paket ein.
Die Komponente "BankView" ist die Komponente, die beim (in diesem Tutorial
beschriebenen) "Forward Engineering" erzeugt wird.
So erstellen Sie eine Verwendungsbeziehung zwischen Schnittstellen und
Komponenten:
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
47
1. Klicken Sie in der Symbolleiste auf das Symbol "Verwendung"
.
2. Ziehen Sie es von der Komponente BankViewGUI zur Komponente BankView.
3. Klicken Sie nochmals auf das Symbol "Verwendung" und ziehen Sie es von der
Komponente BankView zur Schnittstelle IBankAPI.
Durch die Verwendungsbeziehung (<<use>>) wird ein client-Element mit einem
supplier-Element verbunden. In diesem Fall verwendet die Schnittstelle
"IBankInterfaceAPI" die Dienste der Komponenten "BankView" und "BankViewGUI".
© 2016 Altova GmbH
Altova UModel 2017
48
UModel Tutorial
3.6
Ziel dieses Tutorialabschnittes ist es:
die Artefakt-Manifestation von Komponenten zu zeigen
einen neuen Knoten und eine Abhängigkeit zu einem Deployment-Diagramm
(Verteilungsdiagramm) hinzuzufügen
Artefakte zu einem Knoten hinzuzufügen und Beziehungen zwischen diesen zu erstellen
So öffnen Sie das Deployment-Diagramm (Artefakte):
1. Klicken Sie auf das Register "Modell-Struktur", erweitern Sie das Deployment ViewDiagrammpaket und doppelklicken Sie auf das Artefakt-Symbol.
In diesem Diagramm sehen Sie die Manifestation der Komponenten Bank API client und
BankView zu ihren jeweiligen kompilierten .jar-Java-Dateien.
So öffnen Sie das Deployment-Diagramm:
1. Doppelklicken Sie auf das Deployment-Symbol unter dem Deployment View-Paket.
Daraufhin wird das Deployment-Diagramm geöffnet und die physische Architektur des
Systems wird angezeigt, welches derzeit nur den Knoten "Home PC" enthält.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
49
So fügen Sie einen Knoten zu einem Deployment-Diagramm hinzu:
1. Klicken Sie in der Symbolleiste auf das Knoten-Symbol
und klicken Sie rechts vom
Knoten "Home PC", um den Knoten einzufügen.
2. Benennen Sie den Knoten in "Bank" um und ziehen Sie an einer der Kanten, um ihn zu
vergrößern.
So erstellen Sie eine Abhängigkeit zwischen zwei Knoten:
1. Klicken Sie auf das Abhängigkeitssymbol
und ziehen Sie es vom Home PC-Knoten
zum Bank-Knoten.
Dadurch wird eine Abhängigkeit zwischen den beiden Knoten erstellt.
2. Klicken Sie auf dem Register "Eigenschaften" in das Feld name, ändern Sie es in TCP/
IP und drücken Sie zum Bestätigen die Eingabetaste.
Der Name der Abhängigkeit wird oberhalb der Abhängigkeitslinie angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
50
UModel Tutorial
Bitte beachten Sie:
Nachdem Sie auf den Abhängigkeitspfeil (oder eines der benannten Elemente) geklickt
haben, können Sie Text auch direkt über die Tastatur eingeben, ohne zuerst auf das Feld
"Name" klicken zu müssen.
Hinzufügen von Artefakten zu einem Knoten und erstellen von Abhängigkeiten zwischen
diesen:
Erweitern Sie das Deployment View-Paket in der Modell-Struktur, um den Inhalt zu sehen:
1. Klicken Sie auf jedes der einzelnen BankAddresses.ini, BankAPI.jar und
BankView.jar-Artefakte und platzieren Sie sie auf den Diagrammhintergrund (Für jedes
Artefakt werden Deployment-Abhängigkeiten angezeigt).
2. Klicken Sie auf das BankView.jar-Artefakt und ziehen Sie es auf den Home PCKnoten.
Wenn der Vorgang ausgeführt werden kann, erscheint der Knoten markiert.
3. Ziehen Sie auch die anderen Artefakte auf den Home PC Knoten.
Die Artefakte sind nun Teil des Knoten und werden bei einer Neupositionierung des
Knoten mitverschoben.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
51
4. Klicken Sie in der Symbolleiste auf das Abhängigkeitssymbol
und halten Sie die
Strg-Taste gedrückt.
5. Ziehen Sie es vom BankView.jar-Artefakt zum BankAddresses.ini-Artefakt und halten
Sie dabei weiterhin die Strg-Taste gedrückt.
6. Ziehen Sie die Maus vom BankView.jar-Artefakt zum BankAPI.jar-Artefakt.
Bitte beachten Sie:
Wenn Sie ein Artefakt aus einem Knoten auf den Diagrammhintergrund ziehen, wird
automatisch eine Deployment-Abhängigkeit erstellt.
So löschen Sie ein Artefakt aus einem Knoten und dem Projekt:
Klicken Sie auf das zu löschenden Artefakt und drücken Sie die Entf-Taste.
Das Artefakt und alle Abhängigkeiten werden aus dem Knoten und dem Projekt
gelöscht.
So entfernen Sie ein Artefakt aus einem Knoten und seinem Diagramm:
1. Ziehen Sie das Artefakt mit Hilfe von Drag & Drop auf den Diagrammhintergrund.
2. Halten Sie die Strg-Taste gedrückt und drücken Sie Entf.
Das Artefakt und alle Abhängigkeiten werden aus dem aktuellen Diagramm, nicht aber
aus dem Projekt gelöscht.
So erstellen Sie Operationen / Eigenschaften / oder Schachtelungen für Artefakte:
1. Klicken Sie mit der rechten Maustaste auf das Artefakt in der Modell-Struktur.
2. Wählen Sie im Kontextmenü die entsprechende Aktion aus, z.B. Neues Element |
Operation, | Eigenschaft oder | Artefakt.
Das neue Element wird in der Modell-Struktur unterhalb des ausgewählten Artefakts
angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
52
UModel Tutorial
3.7
Altova Website:
UML-Codegenerierung und UML Round-Trip Engineering
Ziel dieses Tutorialabschnittes ist:
die Durchführung einer Projektsyntaxüberprüfung
die Generierung von Projektcode
das Hinzufügen einer neuen Methode zu externem Code, d.h. zur Klasse
"SavingsAccount"
Synchronisieren des UModel Codes mit dem neuen Code
Pakete und Code / Modellsynchronisation:
Code kann auf verschiedenen Ebenen zusammengeführt/synchronisiert werden:
Projekt, Root-Paket-Ebene (Menüeintrag)
Paket-Ebene (Auswahl/Generierung mehrerer Pakete möglich)
Klassen-Ebene (Auswahl/Generierung mehrerer Klassen möglich)
Komponenten-Ebene
Im BankView-Realisierungsdiagramm, wird dargestellt, wie die Komponente "BankView" durch die
sechs Klassen, aus denen sie besteht, realisiert wird. Dies ist die Komponente, die erzeugt wird,
nachdem wir den Abschnitt "Forward Engineering" in diesem Tutorial fertig gestellt haben.
Voraussetzungen für das Erzeugen von Code:
Die Komponente muss von einer oder mehreren Klassen realisiert werden.
Der Komponente muss ein physischer Pfad, d.h. ein Verzeichnis zugewiesen sein. Der
generierte Code wird anschließend in diesem Verzeichnis abgelegt.
Komponenten müssen einzeln so definiert werden, dass Sie in den Code EngineeringVorgang inkludiert werden.
Das Java-, C#- oder VB-Namespace Root-Paket muss definiert werden.
Bitte beachten Sie:
Die Java Namespace Root wurde in der Modell-Struktur im Design-phase | BankView |
com-Paket definiert.
Java-, C#- oder VB-Code kann in einem Projekt kombiniert werden und wird beim RoundTrip Engineering automatisch verarbeitet. Die Datei Bank_MultiLanguage.ump im Ordner "
...\UModelExamples" ist ein Beispiel für ein Projekt für Java- und C#-Code.
So definieren Sie ein Zielverzeichnis für die Codegenerierung:
1. Doppelklicken Sie auf das
Overview Symbol unterhalb des Design-phase-Pakets,
um in die Komponentenübersicht zu wechseln.
2. Klicken Sie im Diagramm auf die BankView-Komponente und beachten Sie die
Einstellungen auf dem Register "Eigenschaften".
3. Klicken Sie auf die Durchsuchen-Schaltfläche
rechts vom Feld "Verzeichnis".
4. Wählen Sie das Zielverzeichnis im Dialogfeld aus, bzw. geben Sie es ein (das
mitgelieferte Beispiel ist definiert als InstallationDir\UModelExamples\Tutorial
\umlcode\bankview) oder klicken Sie auf die Schaltfläche zum Anlegen eines neuen
Ordners, um einen neuen Ordner anzulegen. Der Pfad wird nun im Feld "directory"
angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
53
Bitte beachten Sie:
Bei der Generierung von Java-Code hält sich UModel normalerweise an die Konvention,
Code in Verzeichnissen nach ihrem Namespace zu generieren, z.B. ...\code
\namespace1\C1.java.
Wenn Sie diese Verzeichnisbenennungskonvention auch für C# und VB .NET verwenden
möchten, wählen Sie die Menüoption Extras | Optionen | Code Engineering und
wählen Sie in der Gruppe Namespace für Codedateipfad verwenden die
entsprechende Option aus.
So schließen Sie Komponenten in den Codegenerierungsvorgang ein oder nehmen
diese davon aus:
1. Klicken Sie auf die Komponente BankView GUI.
2. Deaktivieren Sie das Kontrollkästchen "für Code Engineering verwenden" (fall es nicht
bereits deaktiviert ist).
© 2016 Altova GmbH
Altova UModel 2017
54
UModel Tutorial
Überprüfen der Projektsyntax vor der Codegenerierung:
1. Wählen Sie die Menüoption Projekt | Projektsyntax überprüfen.
2. Daraufhin wird eine Syntaxüberprüfung durchgeführt und im Meldungsfenster werden
Meldungen angezeigt, "Bank API-client: Code-Projektdatei oder -verzeichnis wurde
nicht festgelegt" - "IBankAPI: Codedateiname wurde nicht festgelegt".
3. Klicken Sie auf die erste Meldung im Fenster "Meldungen".
4. Das Bank API client-Paket wird in der Modell-Struktur markiert und dessen
Eigenschaften werden auf dem Register "Eigenschaften" angezeigt.
5. Deaktivieren Sie das Kontrollkästchen "use for code engineering" für die Bank API
client-Komponente.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
55
6. Überprüfen Sie die Projektsyntax nochmals durch Auswahl von Projekt | Projektsyntax
überprüfen.
Diesmal werden keine Fehler gemeldet. Wir können nun Programmcode für dieses
Projekt generieren. Nähere Informationen dazu finden Sie unter Überprüfen der
Projektsyntax.
So generieren Sie Projektcode:
1. Klicken Sie auf das BankView-Paket um es auszuwählen.
2. Wählen Sie die Menüoption Projekt | Merge Programmcode aus UModel-Projekt.
3. Wählen Sie die gewünschten Synchronisierungsoptionen im Dialogfeld aus und klicken
Sie auf OK, um fortzufahren (für das Tutorial sind keine Änderungen erforderlich). Nähere
Informationen finden Sie unter Merge Programmcode von UMode-Projekt
© 2016 Altova GmbH
Altova UModel 2017
56
UModel Tutorial
Das Ergebnis des Codegenerierungsvorgangs wird im Meldungsfenster angezeigt.
4. Navigieren Sie zum Zielverzeichnis.
Für das Projekt wurden sechs .Java Dateien erstellt.
Synchronisieren des UModel Modells, nachdem der Java-Code extern aktualisiert wurde:
1. Öffnen Sie die Datei SavingsAccount.java im Texteditor Ihrer Wahl, z.B. in XMLSpy.
2. Fügen Sie die neue Methode zum generierten Code "public float getInterestRate() {}"
hinzu und speichern Sie die Datei.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
57
3. Wechseln Sie zu UModel und rechtsklicken Sie unter dem BankView-Paket auf die
Klasse SavingsAccount
.
4. Wählen Sie die Option Code Engineering | Merge UModel Class von
Programmcode.
Daraufhin wird das Dialogfeld "Synchronisierungseinstellungen" geöffnet, wobei das
Register "Modell von Code" aktiv ist. Für das Tutorial müssen keine Änderungen
vorgenommen werden. Nähere Informationen siehe Merge UModel Projekt aus Code
5. Klicken Sie auf OK, um das Modell aus dem Code zu überführen.
© 2016 Altova GmbH
Altova UModel 2017
58
UModel Tutorial
6. Klicken Sie auf das Register Account Hierarchy, um das Ergebnis des Merge-Vorgangs
zu sehen.
Die neu zum Code hinzugefügte Methode (getInterestRate...) generiert eine neue
Operation in der Klasse "SavingsAccount" von UModel.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
3.8
59
Altova Website:
Reverse Engineering - Java, C#, VB .NET Code
Ziel dieses Tutorialabschnitts ist es:
ein Verzeichnis zu importieren, das Java-Code enthält, der mit XMLSpy generiert wurde
in UModel eine neue Klasse zum Projekt hinzuzufügen
den Programmcode aus einem UModel Paket zu überführen
Die in diesem Beispiel verwendeten Dateien sind in der Datei OrgChart.zip im Ordner ...
\UmodelExamples Ihres Installationsverzeichnisses verfügbar. Entpacken Sie bitte die Datei
"OrgChart.zip" in den Ordner ...UmodelExamples, bevor Sie mit diesem Abschnitt beginnen.
Dadurch wird das Verzeichnis "Orgchart" erstellt, das wir anschließend zum Importieren von
Code verwenden werden.
Importieren von bestehendem Code aus einem Verzeichnis
1. Klicken Sie im Menü Datei auf Neu.
2. Klicken Sie im Menü Projekt auf Quellverzeichnis importieren.
3. Wählen Sie die C#-, Java- oder VB-Version für den Quellcode aus.
und wählen Sie das Verzeichnis
OrgChart aus dem Ordner ...\UModelExamples.
5. Damit UModel Klassen- und Paketdiagramme anhand des Quellcodes generiert,
© 2016 Altova GmbH
Altova UModel 2017
60
UModel Tutorial
aktivieren Sie das Kontrollkästchen "Diagrammgenerierung aktivieren" und klicken
Sie auf "Weiter".
6. Wählen Sie die Optionen Einzelnes Diagramm generieren und/oder Diagramm pro
Paket generieren, wenn Sie danach gefragt werden. Sie können die Diagrammstile
später gegebenenfalls ändern.
7. Klicken Sie zum Fortfahren auf "Weiter". In diesem Dialogfeld können Sie die
Einstellungen für die Generierung von Paketabhängigkeiten definieren.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
61
8. Klicken Sie auf "Fertig stellen". Wenn Sie dazu aufgefordert werden, speichern Sie das
neue Modell in einem Verzeichnis auf Ihrem Rechner. Die Daten werden während der
Eingabe geparst und ein neues Paket namens "OrgChart" wird erstellt.
9. Erweitern Sie das neue Paket und dessen Unterpakete bis Sie zum Paket OrgChart
(com | OrgChart) gelangen. Doppelklicken Sie auf das Diagrammsymbol "Inhalt von
OrgChart":
© 2016 Altova GmbH
Altova UModel 2017
62
UModel Tutorial
Die ausgeblendeten Klassen, aus denen OrgChart besteht, werden auf dem Hauptregister
angezeigt.
Hinzufügen einer neuen Klasse zum OrgChart-Diagramm:
1. Klicken Sie mit der rechten Maustaste in den Hauptbereich und wählen Sie im
Kontextmenü den Befehl Neu | Klasse.
2. Klicken Sie auf die Überschrift der neuen Klasse und geben Sie als Name der neuen
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
63
Klasse CompanyType ein.
3. Fügen Sie mittels der Taste F8 in diesem Beispiel die folgenden neue Operationen zur
Klasse hinzu: CompanyType(), getCompanyType():String,
setCompanyType():String.
Verfügbarmachen der neuen Klasse für die Codegenerierung:
1. Während die Klasse "CompanyType" aktiv ist, klicken Sie in das Feld "Codedateiname"
und geben Sie den Java-Dateinamen der neuen Klasse CompanyType.java ein.
© 2016 Altova GmbH
Altova UModel 2017
64
UModel Tutorial
2. Klicken Sie in der Modellstruktur auf die neue Klasse "CompanyType" und ziehen Sie sie
nach oben auf die OrgChart-Komponente unterhalb des Component View-Pakets. Es
erscheint eine Info, wenn der Mauszeiger sich über einer Komponente befindet.
Mit dieser Methode wird eine Realisierung zwischen einer Klasse und einer Komponente
erstellt, sodass Sie keine Komponenten- oder Deployment-Diagramme verwenden
müssen. Erweitern Sie das Element Beziehungen unterhalb der Komponente
"Orgchart" um die neu erstellte Realisierung zu sehen.
Altova UModel 2017
© 2016 Altova GmbH
UModel Tutorial
65
Merge von Programmcode aus einem Paket
1. Rechtsklicken Sie auf das Paket OrgChart, wählen Sie Code Engineering | Merge
Programmcode von UModel-Paket und bestätigen Sie den Vorgang mit der
Eingabetaste.
Im Meldungsfenster wird die Syntaxüberprüfung angezeigt, die durchgeführt wird, und der
Status des Synchronisierungsvorgangs.
Nach Abschluss des Vorgangs ist die neue Klasse CompanyType.java zum Ordner ...
\OrgChart\com\OrgChart\ hinzugefügt.
Alle Methoden-Body-Bereiche und Änderungen am Code werden entweder
auskommentiert oder gelöscht, je nachdem, welche Option im Dialogfeld
"Synchronisierungseinstellungen" in der Gruppe "Code beim Löschen" ausgewählt
wurde.
Sie wissen nun, wie man ein Modellierungsprojekt mit Hilfe von Forward Engineering erstellt und
haben ein komplettes Round-Trip Engineering durchgeführt. Im restlichen Teil dieser
Dokumentation erfahren Sie, wie man die besten Ergebnisse beim Erstellen von Modellen mit
UModel erzielt.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 4
68
4
UModel besteht aus einer Reihe von Fensterbereichen auf der linken Seite und einem größeren
Diagrammregister auf der rechten Seite. Über die Fensterbereiche auf der linken Seite können Sie
Ihr UModel-Projekt nach verschiedenen Aspekten anzeigen bzw. darin navigieren und Daten direkt
editieren.
Die Fensterbereiche nennen sich: Modell-Struktur, Eigenschaften und Übersicht. Der Arbeits-/
Ansichtsbereich rechts davon ist das UModel-Diagrammregister, auf dem derzeit das
Klassendiagramm des BankView Main-Pakets angezeigt wird.
Bitte beachten Sie:
Alle Fensterbereiche sowie alle Diagrammregister können über die "Suchen"-DropdownListe in der Hauptsymbolleiste (im Screenshot unten enthält sie den Text "account")
oder durch Drücken von Strg + F durchsucht werden.
Altova UModel 2017
© 2016 Altova GmbH
4.1
Modell-Struktur
69
Modell-Struktur
Register "Modell-Struktur"
Über das Register "Modell-Struktur" können Sie Modellelemente direkt in der Modell-Struktur
manipulieren und bestimmte Elemente auf dem Register "Design" anzeigen, bzw. darin
navigieren. Wenn Sie mit der rechten Maustaste auf ein Element klicken, wird das Kontextmenü
geöffnet, über das bestimmte Befehle zur Auswahl stehen. Der Inhalt des Kontextmenüs hängt
vom ausgewählten Element ab.
Modellelemente im Modell-Strukturbereich können direkt manipuliert werden. Sie können
Folgendes tun:
hinzufügen /einfügen
kopieren oder verschieben
löschen
umbenennen
nach verschiedenen Kriterien sortieren
einschränken
Auf dem Register "Modell-Struktur" ist jeder Ordner ein UML-Paket!
Hinzufügen eines neuen Pakets (oder eines beliebigen anderen Modellierungselements):
1. Rechtsklicken Sie auf den Ordner, unter dem das neue Paket/Element angezeigt werden
soll.
2. Wählen Sie Neu | Paket (oder das jeweilige Modellelement).
Kopieren oder Verschieben von Modellelementen:
1. Verwenden Sie die Windows-Standardbefehle "Ausschneiden", "Kopieren" oder
"Einfügen" oder
2. Ziehen Sie Modellelemente in andere Pakete. Durch Ziehen eines Elements verschieben
Sie es. Wenn Sie die Strg-Taste gedrückt halten, während Sie das Element ziehen, wird
eine Kopie erstellt.
In manchen Fällen wird beim Ziehen von Elementen eine Meldung angezeigt, dass die
Option "keine Sortierung" aktiviert werden muss, damit Sie die Aktion durchführen
können. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und
© 2016 Altova GmbH
Altova UModel 2017
70
Modell-Struktur
Einfügen in UModel Diagrammen.
Sortieren von Elementen in der Modell-Struktur (unter Aktivierung der Option "keine
Sortierung"):
1. Rechtsklicken Sie auf den leeren Hintergrund des Registers "Modell-Struktur".
2. Wählen Sie Sortieren | keine Sortierung.
Elemente können nun überall in der Modell-Struktur positioniert werden.
Bitte beachten Sie:
Über das Popup-Menü "Sortieren" können Sie die Sortiereigenschaften von
Eigenschaften und Operationen einzeln definieren.
Umbenennen eines Elements:
1. Doppelklicken Sie auf den Elementnamen und editieren Sie ihn.
Die Pakete "Root" und "Component View" sind die einzigen zwei Elemente, die nicht
umbenannt werden können.
Löschen eines Elements:
1. Klicken Sie auf das zu löschende Element (mit Strg + Klick können mehrere Elemente
markiert werden).
2. Drücken Sie die Entf-Taste.
Das Modellierungselement wird aus der Modell-Struktur gelöscht. D.h. es wird
gleichzeitig auch aus dem Diagrammregister gelöscht, falls es dort zu sehen ist, sowie
aus dem Projekt. Mit Hilfe von Strg + Entf können Elemente aus einem Diagramm
gelöscht werden, ohne auch aus dem Projekt gelöscht zu werden. Nähere Informationen
dazu finden Sie unter Löschen von Elementen.
So öffnen Sie ein Diagramm auf dem Diagrammregister:
1. Doppelklicken Sie auf das Diagrammsymbol
des Diagramms, das Sie auf dem
Diagrammregister anzeigen wollen.
Darstellung der Symbole der Modellierungselemente in der Modell-Struktur
Pakettypen:
UML-Pakete
Java Namespace Root-Paket
C# Namespace Root-Paket
Visual Basic Root-Paket
XML Schema Root-Paket
Java-, C#- oder VB-Code-Paket (bei Generierung von Code werden Paketdeklarationen erstellt)
Diagrammtypen:
Aktivitätsdiagramm
Klassendiagramm
Komponentendiagramm
Deployment-Diagramm
Altova UModel 2017
Profildiagramm
Sequenzdiagramm
Zustandsdiagramm
SysML-Diagramme (9
Diagrammtypen)
Use Case-Diagramm
XML-Schema-Diagramm
© 2016 Altova GmbH
Objektdiagramm
Modell-Struktur
71
Business Process Modeling
Notation
Paketdiagramm
Elementtypen:
Ein Element, das derzeit im aktiven Diagramm zu sehen ist, wird mit einem blauen Punkt am
unteren Rand dargestellt. In diesem Fall handelt es sich um ein Klassenelement.
Klassen-Instanz/Objekt
Klassen-Instanz-Slot
Klasse
Eigenschaft
Operation
Parameter
Akteur (sichtbar im aktiven Use Case-Diagramm)
Use Case
Komponente
Knoten
Artefakt
Schnittstelle
Beziehungen (/Paket)
Einschränkungen
Öffnen / Erweitern von Paketen in der Modell-Strukturansicht:
Es gibt zwei Methoden, Pakete in der Baumstrukturansicht zu öffnen. Mit der einen werden alle
Pakete und Unterpakete geöffnet, mit der anderen wird das aktuelle Paket geöffnet.
Klicken Sie auf das zu öffnende Paket und:
Drücken Sie die *-Taste, um das aktuelle Paket und alle Unterpakete zu öffnen
Drücken Sie die +-Taste, um das aktuelle Paket zu öffnen.
Zum Reduzieren der Pakete drücken Sie die Taste -.Um alle Pakete zu reduzieren,
klicken Sie auf das Root-Paket und drücken Sie -.
Sie können dafür sowohl die Tasten der Standardtastatur als auch die des Zahlenblocks
verwenden.
So suchen Sie auf dem/den Diagrammregister(n) Modellierungselemente:
Beim Navigieren durch die Elemente in der Modell-Struktur möchten Sie eventuell sehen, wo oder
ob das Element tatsächlich in einem Modell-Diagramm vorhanden ist. Zum Suchen von
Elementen stehen zwei Methoden zur Verfügung:
1. Rechtsklicken Sie auf das Element, das Sie auf dem Register "Modell-Struktur" sehen
möchten, und wählen Sie:
Element in aktivem Diagramm anzeigen - um es auf demselben Diagrammregistertyp
zu suchen
Element in allen Diagrammen anzeigen - wenn das derzeit aktive Diagramm sich vom
ausgewählten Modellelement unterscheidet.
So generieren Sie eine Liste von Elementen, die in keinem Diagramm verwendet
werden:
© 2016 Altova GmbH
Altova UModel 2017
72
Modell-Struktur
1. Rechtsklicken Sie auf das gewünschte Paket.
2. Wählen Sie die Menüoption "In keinem Diagramm verwendete Elemente auflisten".
Im Meldungsfenster wird daraufhin eine Liste der nicht verwendeten Elemente angezeigt.
Die in Klammer angezeigte Liste enthält die spezifischen Elemente, die ausgewählt
wurden und in der Liste der nicht verwendeten Elemente aufscheinen sollen. Nähere
Informationen dazu finden Sie im Referenzabschnitt unter dem Register Ansicht unter
Extras | Optionen.
So suchen Sie die fehlenden Elemente in der Modell-Struktur:
Klicken Sie im Meldungsbereich auf den Elementnamen.
Bitte beachten Sie:
Die nicht verwendeten Elemente werden für das aktuelle Paket und dessen Unterpakete
angezeigt.
Pakete auf dem Register "Modell-Struktur":
Beim Start, d.h. wenn kein Projekt geladen ist, sind nur die Pakete "Root" und "Component View"
zu sehen.
Pakete können an jeder Stelle in der Modell-Struktur erstellt oder gelöscht werden
Pakete sind die Behälter für alle anderen UML-Modellierungselemente, Use CaseDiagramme usw.
Pakete/Inhalt können/kann in andere Pakete in der Modell-Struktur (und auch in gültige
Modell-Diagramme auf dem Diagrammregister) verschoben/kopiert werden
Paketen und deren Inhalt können gemäß verschiedenen Kriterien sortiert werden
Pakete können in andere Pakete platziert werden
Pakete können beim Generieren oder Synchronisieren von Code als Quell- oder
Zielelemente verwendet werden
Generieren/Zusammenführen von Code:
UModel gestattet Ihnen, Programmcode direkt von der Modell-Struktur aus zu generieren oder
zusammenzuführen. Nähere Informationen dazu siehe: Synchronisieren von Modell- und
Quellcode.
Einschränken von UML-Elementen
Es können für die meisten Modellelemente in UModel Einschränkungen definiert werden.
Beachten Sie bitte, dass diese bei der Syntaxüberprüfung nicht berücksichtigt werden, da
Einschränkungen nicht Teil der Java-Codegenerierung sind.
So schränken Sie ein Element ein (Modell-Struktur):
1. Rechtsklicken Sie auf das gewünschte Element und wählen Sie Neu | Einschränkung.
2. Geben Sie den Namen der Einschränkung ein und drücken Sie die Eingabetaste.
3. Klicken Sie auf dem Register "Eigenschaften" in das Feld "Spezifikation" und geben Sie
die Einschränkung ein, z.B. name length > 10.
Altova UModel 2017
© 2016 Altova GmbH
Modell-Struktur
73
So schränken Sie ein Element in UML-Diagrammen ein:
1. Doppelklicken Sie auf das jeweilige Element, um es editieren zu können.
2. Geben Sie den Namen der Einschränkung innerhalb einer geschwungenen Klammer ein
z.B. interestRate:float #{interestRate >=0}.
So weisen Sie eine Einschränkung mehreren Modellierungselementen zu:
1. Rechtsklicken Sie auf dem Register "Eigenschaften" auf das Feld "Eingeschränkte
Elemente".
2. Wählen Sie "Element eingeschränkten Elementen hinzufügen".
Daraufhin wird das Dialogfeld "Einzuschränkendes Element auswählen" geöffnet.
3. Wählen Sie das jeweilige Element aus, dem Sie die aktuelle Einschränkung zuweisen
möchten.
Das Feld "constrained element" enthält die Namen der Modellierungselemente, denen es
zugewiesen wurde. In der obigen Abbildung wurde Constraint1 den Paketen bankview
und com zugewiesen.
© 2016 Altova GmbH
Altova UModel 2017
74
4.2
Diagramm-Struktur
Diagramm-Struktur
Register "Diagramm-Struktur"
Auf diesem Register werden die aktuell verfügbaren UModel-Diagramme auf zwei Arten
dargestellt:
Gruppiert nach Diagrammtyp, in alphabetischer Reihenfolge
Als alphabetische Liste aller Projektdiagramme
Bitte beachten Sie:
Diagramme können durch Rechtsklick auf das Register "Diagramm-Struktur" und
Auswahl des entsprechenden Befehls hinzugefügt oder davon gelöscht werden.
So öffnen Sie ein Diagramm auf dem Diagrammregister:
Doppelklicken Sie auf das Diagramm, das Sie auf dem Diagrammregister anzeigen
wollen.
So zeigen Sie alle Diagramme innerhalb ihrer jeweiligen Modellgruppen an:
Rechtsklicken Sie in das Fenster und aktivieren Sie die Option "Diagramme nach
Diagrammtyp gruppieren".
Diagramme werden innerhalb ihrer Gruppe in alphabetischer Reihenfolge geordnet.
So zeigen Sie alle Diagrammtypen (alphabetisch) in Form einer Liste an:
Rechtsklicken Sie in das Fenster und deaktivieren Sie die Option "Diagramme nach
Diagrammtyp gruppieren".
Altova UModel 2017
© 2016 Altova GmbH
Diagramm-Struktur
75
Alle Diagramme werden in Form einer alphabetisch sortierten Liste angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
76
4.3
Favoriten
Favoriten
Register "Favoriten"
Dieses Register dient als benutzerdefinierter Behälter oder Bibliothek für alle Arten von
benannten UML-Elementen, also Klassen, Objekte, Assoziationen usw. nicht aber für
ProfileApplication- oder Generalisierungsbeziehungen. Auf diese Art können Sie Ihre persönliche
Liste von Modellierungselementen erstellen, die zur schnellen Auswahl zur Verfügung stehen.
Der Inhalt des Registers "Favoriten" wird automatisch mit jeder Projektdatei gespeichert. Um
diese Einstellungen zu ändern, wählen Sie die Menüoption Extras | Optionen und das Register
"Datei" und deaktivieren Sie das Kontrollkästchen "Mit Projektdatei laden und speichern".
So fügen Sie ein vorhandenes Modellierungselement zum Register "Favoriten" hinzu:
1. Rechtsklicken Sie auf dem Register "Modell-Struktur" oder im Diagramm-Arbeitsbereich
auf ein Element.
2. Wählen Sie den Menüeintrag Zu Favoriten hinzufügen.
3. Klicken Sie auf das Register "Favoriten", um das Element zu sehen.
Das Element, das auf dem Register "Favoriten" zu sehen ist, ist eine Ansicht eines
existierenden Elements, d.h. es handelt sich hier nicht um eine Kopie oder einen Klon!
So fügen Sie ein NEUES Element zum Register "Favoriten" hinzu:
1. Rechtsklicken Sie auf ein zuvor hinzugefügtes Paket, zu dem Sie das Element
hinzufügen möchten.
2. Wählen Sie im Kontextmenü den Eintrag Neu | "modeling element". Beim "modeling
element" handelt es sich hierbei um eine Klasse, eine Komponente oder ein anderes
Modellierungselement aus dem Kontextmenü.
Neue Elemente werden zum selben Element/Paket im Projekt hinzugefügt und sind daher
auch auf dem Register "Modell-Struktur" zu sehen.
So ENTFERNEN Sie ein Element vom Register "Favoriten":
1. Rechtsklicken Sie auf dasselbe Element/Paket, das Sie zu Favoriten hinzugefügt haben.
2. Wählen Sie die Option Aus Favoriten entfernen.
Bitte beachten Sie:
Sie können Elemente, die Sie zum Register "Favoriten" hinzugefügt haben, sowohl über
das Register "Favoriten" als auch über das Register "Modell-Struktur" hinzufügen und
entfernen.
Altova UModel 2017
© 2016 Altova GmbH
Favoriten
77
Löschen von Elementen vom Register "Favoriten":
1. Rechtsklicken Sie auf das zu löschende Element und drücken Sie die Entf-Taste.
Daraufhin wird ein Meldungsfeld angezeigt, in dem Sie informiert werden, dass das
Element aus dem Projekt gelöscht wird.
2. Klicken Sie auf OK, wenn Sie es aus dem Projekt löschen möchten.
3. Klicken Sie auf "Abbrechen", um das Element beizubehalten und gehen Sie vor, wie
oben beschrieben, um das Element aus dem Register "Favoriten" zu löschen.
© 2016 Altova GmbH
Altova UModel 2017
78
4.4
Eigenschaften
Eigenschaften
Register Eigenschaften
Auf dem Register "Eigenschaften" werden die UML-Eigenschaften des aktuell aktiven Elements
angezeigt.
Wenn Sie auf ein beliebiges Element in einer/auf einem der zur Verfügung stehenden
Ansichten, Registern klicken, werden seine Eigenschaften angezeigt.
Sobald die Eigenschaften angezeigt werden, können sie durch Eingabe von Daten oder
Auswahl verschiedener Optionen auf dem Register geändert oder ergänzt werden.
Ausgewählte Eigenschaften können auch auf den Diagrammregistern gesucht werden.
Wählen Sie dazu im Kontextmenü die Option "In aktivem Diagramm anzeigen" aus.
Auswählen in der Modellstruktur
Wenn Sie in einem Klassendiagramm auf ein Attribut klicken, werden seine Eigenschaften auf
dem Register "Eigenschaften" angezeigt. Um diese in der Modell-Struktur zu finden:
1. Klicken Sie mit der rechten Maustaste auf den Typ-Eintrag des Attributs auf dem
Register "Eigenschaften".
2. Wählen Sie den Eintrag "In Modell-Struktur auswählen" im Kontextmenü aus.
Altova UModel 2017
© 2016 Altova GmbH
Eigenschaften
79
Die IBankAPI-Schnittstelle wird nun in der Modell-Struktur angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
80
4.5
Stile
Stile
Das Register "Stile"
Auf dem Register "Stile" können Sie Attribute von Diagrammen oder Elementen, die in der
Diagrammansicht angezeigt werden, ansehen oder ändern.
Diese Stil-Attribute lassen sich in zwei allgemeine Gruppen einteilen:
Formatierungseinstellungen; wie z.B. Schriftgröße, -breite, Farbe usw.
Anzeigeeinstellungen/-optionen; Hintergrundfarbe anzeigen, Raster, Sichtbarkeit usw.
Das Register "Stile" ist in verschiedene Kategorien/Abschnitte unterteilt, die Sie durch Klicken auf
das Listenfeld "Stile" auswählen können. Der Inhalt des Listenfelds ist vom aktuell ausgewählten
Modellelement abhängig.
Durch Klicken auf ein Element auf einem Diagrammregister wird automatisch der Kontext
"Elementstile" ausgewählt. Bei Klicken auf ein Element auf dem Register "Modell-Struktur" wird
der Kontext "Projektstile" ausgewählt.
Die Anwendungsreihenfolge für die Stile ist von unten nach oben, d.h. Änderungen, die auf
einer spezifischeren Ebene vorgenommen wurden, setzen allgemeinere Einstellungen außer
Kraft. So setzen z.B. Änderungen (an einem Objekt) auf der Elementstilebene die aktuellen
Elementfamilie und Projektstil-Einstellungen außer Kraft. Wenn Sie jedoch ein anderes Objekt
auswählen und die Elementfamilie - Stile-Einstellungen ändern, werden alle anderen Objekte mit
Ausnahme des soeben auf der Ebene Elementstile geänderten Objekts aktualisiert.
Bitte beachten Sie:
Altova UModel 2017
© 2016 Altova GmbH
Stile
81
Alle an Modellelementen vorgenommenen Stiländerungen können rückgängig gemacht
werden!
Elementstile:
Gilt für das aktuell ausgewählte Element im aktuell aktiven Diagramm. Mehrfachauswahl ist
möglich.
Stile von Elementen mit diesem Stereotyp:
Gilt für die aktuell ausgewählte Stereotypklasse im Diagramm. Nähere Informationen dazu siehe
Benutzerdefinierte Stereotypstile.
Elementfamilie Stile:
Gilt für alle Elemente desselben Typs, d.h. der ausgewählten Elementfamilie, z.B. können Sie alle
Komponentenelemente in der Farbe "Aqua" anzeigen lassen. Daraufhin werden alle Komponenten
in Komponenten- und Deployment-Diagrammen in Aqua angezeigt.
Knotenstile/Linienarten:
"Knoten" gilt für alle rechteckigen Objekte.
"Linien" gilt für alle Konnektoren: Assoziations-, Abhängigkeits-, Realisierungslinien usw. für das
gesamte Projekt.
Projektstile:
Projektstile gelten für das aktuelle UModel Projekt als Ganzes (wenn Sie z.B. die
Standardschriftart "Arial" für alle Texte in allen Diagrammen des Projekts in "Times New Roman"
ändern möchten.
Diagrammstile:
Diese Stile stehen nur zur Verfügung, wenn Sie auf einen Diagrammhintergrund klicken bzw. ihn
auswählen. Wenn Sie Einstellungen hier ändern, wird davon nur das einzelne UML-Diagramm, für
das die Einstellungen im Projekt definiert sind, betroffen.
So ändern Sie die Einstellungen für alle Diagramme eines Projekts:
1. Klicken Sie in das jeweilige Diagramm,
2. Wählen Sie im Listenfeld den Eintrag Projektstile und scrollen Sie zum unteren Rand
des Registers.
3. Wählen Sie eine der Diag.yyy-Optionen z.B. Diag.Hintergrundfarbe.
Daraufhin wird die Hintergrundfarbe aller Diagramme im aktuellen Projekt geändert.
Anzeige von Stilen bei Auswahl mehrerer Elemente:
Wenn im Diagrammfenster mehrere Elemente ausgewählt sind, werden alle unterschiedlichen
Stilwerte im entsprechenden Feld angezeigt. In der Abbildung unten wurden Class1 und Class2
ausgewählt.
Im Feld "Füllfarbe" werden die Werte für die einzelnen Elemente angezeigt, in diesem Fall
Aquamarin und Silber.
© 2016 Altova GmbH
Altova UModel 2017
82
Stile
Anzeige von einander überlappenden Stilen:
Wenn ein Stil durch einen Stil auf einer untergeordneten Ebene außer Kraft gesetzt wird, wird auf
dem Register "Stile" im entsprechenden Feld ein kleines rotes Dreieck angezeigt.
Wenn Sie den Mauszeiger über das Feld platzieren, wird ein Popup-Fenster angezeigt, in dem
angegeben wird, welcher Stil Vorrang hat.
Beispiel:
Für die Elemente "Enumeration", "Paket" und "Profil" sind in den Elementfamilienstileinstellungen
Standardfüllfarben definiert. Um die Füllfarben auf Projektebene zu ändern, löschen Sie den Wert
unter "Elementfamilie - Stile", indem Sie im Dropdown-Listenfeld den leeren Eintrag auswählen,
wählen Sie in der Auswahlliste "Stile" den Eintrag "Projektstile" aus und ändern Sie dort die
Füllfarbe.
Altova UModel 2017
© 2016 Altova GmbH
4.6
Hierarchie
83
Hierarchie
Register "Hierarchie"
Auf dem Register "Hierarchie" werden alle Beziehungen des aktuell ausgewählten
Modellierungselements in zwei verschiedenen Ansichten angezeigt. Das Modellierungselement
kann in einem Modellierungsdiagramm, der Modell-Struktur oder auf dem Register "Favoriten"
ausgewählt werden.
Bitte beachten Sie:
Allgemeine Einstellungen für das Register "Hierarchie" werden über die Menüoption
Extras | Optionen | Ansicht in der Gruppe "Hierarchie" im unteren Bereich des
Dialogfelds vorgenommen.
Strukturansicht anzeigen
In dieser Ansicht sehen Sie mehrere Beziehungen des aktuell ausgewählten Elements z.B.
SchemaString. Wenn Sie auf die verschiedenen Schaltflächen in der Symbolleiste klicken,
können Sie alle Arten von Beziehungen anzeigen oder nur einige davon, indem Sie die jeweiligen
Schaltflächen durch Anklicken aktivieren. In der Abbildung oben sind alle Schaltfläche aktiv, daher
werden in einer Strukturansicht auch alle Beziehungen angezeigt.
Wenn Sie auf dem Register auf eines der Elementsymbole doppelklicken, werden die
Beziehungen dieses Elements angezeigt.
Graph. Ansicht anzeigen
© 2016 Altova GmbH
Altova UModel 2017
84
Hierarchie
In dieser Ansicht wird eine einzige Gruppe von Beziehungen in einer hierarchischen Übersicht
angezeigt. Es kann immer nur jeweils eine der Beziehungsschaltflächen aktiv sein. In der
Abbildung ist die Schaltfläche "Generalisierungen anzeigen" gerade aktiv.
Wenn Sie auf dem Register auf eines der Elementsymbole klicken, z.B. SchemaTypeNumber,
werden die Beziehungen dieses Elements angezeigt.
Das aktuell ausgewählte Element ist nun SchemaTypeNumber.
Erstellen eines neuen Diagramms anhand des Fensterinhalts:
Der aktuelle Inhalt des Fensters "Graph. Ansicht" kann in einem neuen Diagramm angezeigt
werden.
Altova UModel 2017
© 2016 Altova GmbH
Hierarchie
85
1. Rechtsklicken Sie in das Fenster "Graph. Ansicht" und wählen Sie den Befehl
Diagramm als diesen Graph erstellen.
2. Bearbeiten Sie den Namen des Diagramms gegebenenfalls, wählen Sie die Stiloptionen
aus und klicken Sie auf OK.
Ein neues Diagramm wird erstellt.
© 2016 Altova GmbH
Altova UModel 2017
86
4.7
Übersicht - Dokumentation
Übersicht - Dokumentation
Register Übersicht
Auf dem Register "Übersicht" werden die Umrisse des aktuell aktiven Diagramms in Form einer
Übersicht angezeigt. Wenn Sie auf das rote Rechteck klicken und es ziehen, verschiebt sich der
angezeigte Bereich auf dem Diagrammregister.
Altova UModel 2017
© 2016 Altova GmbH
4.8
Dokumentation
87
Dokumentation
Register Dokumentation
Über dieses Register können alle der auf dem Register "Modell-Struktur" verfügbaren Elemente
dokumentiert werden. Klicken Sie auf das gewünschte Element und geben Sie den Text auf dem
Register "Dokumentation" ein. Dabei werden auch die Tastenkombinationen für die
Standardbearbeitungsbefehle "Ausschneiden", "Kopieren" und "Einfügen" unterstützt.
Dokumentation und Code Engineering:
Beim Code Engineering wird nur die Dokumentation zu Klassen und Schnittstellen als Input bzw.
Output verwendet. Dazu gehört auch Dokumentation, die für Klassen-/Schnittstelleneigenschaften
und -operationen definiert wurde.
1. Wählen Sie Projekt | Synchronisierungseinstellungen.
2. Aktivieren Sie das Kontrollkästchen "Dokumentation als JavaDocs schreiben" um die
Ausgabe von Dokumentation zu aktivieren.
Bitte beachten Sie:
Beim Import von XML-Schemas wird nur die erste Annotation eines complexoder simpleType im
Fenster "Dokumentation" angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
88
4.9
Meldungen
Meldungen
Im Fenster "Meldungen" werden beim Zusammenführen von Code oder beim Überprüfen der
Projektsyntax Meldungen, Hinweise und Fehlermeldungen angezeigt.
Wenn Sie auf die Fehlermeldung klicken, wird das entsprechende Element in der Modell-Struktur
und im dazugehörigen Diagramm markiert, falls das Diagramm gerade aktiv/offen ist.
Altova UModel 2017
© 2016 Altova GmbH
Diagrammfenster
89
4.10 Diagrammfenster
Alle aktuell geöffneten UModel-Diagramme werden im Diagrammfenster auf einzelnen Registern
angezeigt.
So erstellen Sie ein neues Diagramm:
1. Klicken Sie auf dem Register "Modell-Struktur" auf ein Paket.
2. Wählen Sie Neu | YYY Diagramm.
So erstellen Sie ein neues Diagramm, das den Inhalt eines bestehenden Pakets enthält:
1. Rechtsklicken Sie auf ein Paket und wählen Sie In neuem Diagramm anzeigen |
Inhalt.
So öffnen Sie ein Diagramm bzw. rufen es auf:
Doppelklicken Sie auf das Diagrammsymbol auf einem der Register der Modell-Struktur,
um das Diagramm zu öffnen.
Klicken Sie auf eines der Register im Diagrammfenster (um das Diagramm aufzurufen).
So schließen Sie alle Diagramme mit Ausnahme des aktiven:
Rechtsklicken Sie auf das Diagrammregister, das offen bleiben soll, und wählen Sie die
Option Alle bis auf die aktiven schließen.
Löschen eines Diagramms:
Klicken Sie in der Modell-Struktur auf das Diagrammsymbol und drücken Sie die EntfTaste.
Verschieben von Diagrammen in einem Projekt:
Ziehen Sie das Diagrammsymbol in ein beliebiges anderes Paket auf dem Register
"Modell-Struktur".
Unter Umständen müssen Sie die Option "Keine Sortierung" aktivieren, um das
Diagramm verschieben zu können.
Suchen (Löschen) von Klasseneigenschaften und Optionen aus der Modell-Struktur:
Eigenschaften und Optionen können auch direkt aus der Modell-Struktur gelöscht werden. Dazu
© 2016 Altova GmbH
Altova UModel 2017
90
Diagrammfenster
müssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1" in die
Klasse "Account" eingefügt (drücken Sie zum Einfügen F8 und anschließend die Eingabetaste):
1. Rechtsklicken Sie in der Klasse "Account" auf Operation1.
2. Wählen Sie die Option "In Modell-Struktur auswählen" oder drücken Sie F4.
Der Eintrag Operation1 erscheint nun auf dem Register "Modell-Struktur" unter Account
markiert.
3. Drücken Sie die Entf-Taste, um die Operation aus der Klasse und dem Projekt zu
löschen!
Beachten Sie, dass Sie durch Drücken von F4 beinahe jedes Modellierungselement in der
Modell-Struktur finden können.
Bitte beachten Sie:
Sie können beim Anzeigen von Attributeigenschaften auch vom Fenster "Eigenschaften"
zur Modell-Struktur navigieren. Nähere Informationen dazu finden Sie in der
Benutzerreferenz unter Eigenschaften.
Löschen von Elementen aus einem Diagramm:
Löschen von Elementen aus dem Diagramm und dem Projekt!
Wählen Sie das zu löschende Element aus und drücken Sie die Entf-Taste.
Löschen von Elementen nur aus dem Diagramm - nicht aus dem Projekt!
1. Wählen Sie das zu löschende Element aus
2. Halten Sie die Strg-Taste und drücken Sie die Entf-Taste.
Mit Hilfe einer Funktion zum automatischen Layouten können Sie definieren, wie Ihr Diagramm
visuell strukturiert werden soll. Rechtsklicken Sie auf den Diagrammhintergrund und wählen Sie
entweder:
Automatisches Layout | Zentriert oder
Automatisches Layout | Hierarchisch
Automatisches Layout | Block
Anzeigen von Beziehungen zwischen Modellelementen:
Altova UModel 2017
© 2016 Altova GmbH
Diagrammfenster
91
1. Rechtsklicken Sie auf das entsprechende Element und wählen Sie den Befehl Anzeigen.
Das unten gezeigte Popup-Menü ist kontextspezifisch, d.h. es stehen nur die Optionen
zur Verfügung, die für das jeweilige Element relevant sind.
So zeigen Sie Textlabels an bzw. blenden sie aus:
Klicken Sie mit der rechten Maustaste auf eine Klasse oder einen Assoziationspfeil und
wählen Sie den Befehl Textlabels anzeigen | Alle Textlabels anzeigen
(ausblenden).
So zeigen Sie ein Klassenattribut/eine Klasseneigenschaft als Assoziation an:
1. Rechtsklicken Sie auf die Eigenschaft in der Klasse.
© 2016 Altova GmbH
Altova UModel 2017
92
Diagrammfenster
2. Wählen Sie die Menüoption Anzeigen | "EigenschaftXX" als Assoziation.
Daraufhin wird die referenzierte Klasse eingefügt/geöffnet und die jeweilige Assoziation
wird angezeigt.
So zeigen Sie Quellcodekommentare im Modelldiagramm an:
Klicken Sie mit der rechten Maustaste in das Diagrammfenster und wählen Sie den
Befehl Anzeigen | Anmerkende Kommentare.
Auf diese Art können Sie Quellcodekommentare zum Dokument (DocComments), die
auch im Fenster "Dokumentation" angezeigt werden, direkt im Modelldiagramm
bearbeiten.
So passen Sie die Linienstärke in einem Projekt an:
1. Klicken Sie in ein beliebiges Diagramm und klicken Sie anschließend auf das Register
"Stile".
Stellen Sie sicher, dass in der Auswahlliste der Eintrag "Projektstile" aktiv ist.
2. Scrollen Sie hinunter zum Eintrag "Linienbreite" und wählen Sie den gewünschten Wert.
Diese Änderung wirkt sich auf die Stärke aller Assoziations-, Aggregations-,
Generalisierungslinien usw. in allen Diagrammen des aktuellen UModel-Projekts aus.
Altova UModel 2017
© 2016 Altova GmbH
Diagrammfenster
93
4.10.1 Diagrammeigenschaften
Konfigurieren von Diagrammeigenschaften
Klicken Sie auf den Diagrammhintergrund und wählen Sie anschließend einen der Stile aus dem
Listenfeld "Styles" aus. Nähere Informationen finden Sie unter Fensterbereich "Stile".
So vergrößern Sie ein Diagramm:
Die Größe des Diagrammregisters hängt von den Elementen und ihrer Platzierung ab.
Ziehen Sie ein Element zu einem der Ränder des Diagrammregisters, um automatisch
durch das Register zu scrollen und es zu vergrößern.
Positionieren von Modellierungselementen - das Raster
Modellierungselemente können manuell positioniert werden oder an einem sichtbaren/
unsichtbaren Raster in einem Diagramm ausgerichtet werden.
Dient zum Ein- und Ausblenden des Rasters
Dient zum Ausrichten von Elementen an einem sichtbaren / unsichtbaren Raster
Anzeigen von UML-Diagrammüberschriften
Dient zum Ein- und Ausblenden von UML-Diagrammüberschriften, d.h. des
Rahmens rund um ein Diagramm mit dem Namen in der linken oberen Ecke.
Ausrichten von Modellierungselementen
Modellierungselemente können in ihrer Größe und Position an anderen Elementen ausgerichtet
werden, z.B. zentriert, links- oder rechtsbündig ausgerichtet usw.
Bitte beachten Sie:
Wenn Sie mehrere Elemente markieren, wird für die Aktion, die Sie daran ausführen, als Vorlage
das zuletzt ausgewählte Element verwendet. Wenn Sie z.B. drei Klassenelemente auswählen und
auf die Schaltfläche "Breite angleichen" klicken, dann werden alle drei Elemente in der Breite an
die zuletzt ausgewählte Klasse angepasst.
Das gleiche gilt auch bei Markierung mehrerer Objekte mit der Marquee-Technik (Aufziehen eines
Rechtecks). Hier dient das zuletzt ausgewählte Element als Vorlage für die anderen markierten
Objekte
Schaltflächenfunktionen für die einzelnen Schaltflächengruppen:
© 2016 Altova GmbH
Altova UModel 2017
94
Diagrammfenster
Linksbündig, Rechtsbündig
Bündig oben, Bündig unten
Vertikal zentrieren, Horizontal zentrieren
Waagrecht anordnen, Senkrecht anordnen
Horizontal anordnen, vertikal anordnen
Breite angleichen, Höhe angleichen, Größe angleichen.
Verbessertes Autokomplettierungsfenster - Auswählen von Datentypen
Wenn Sie Datentypen für Operationen oder Eigenschaften eingeben, wird automatisch ein
Autokomplettierungsfenster angezeigt, das die folgenden Funktionen aufweist:
Bei Klick auf einen Spaltennamen wird das Fenster in aufsteigender/absteigender
Reihenfolge nach diesem Attribut sortiert.
Durch Ziehen der rechten unteren Ecke können Sie die Größe des Fensters anpassen.
Sie können den Inhalt des Fensters durch Klicken auf das entsprechende
Kategoriesymbol am unteren Rand des Fensters filtern.
Mit der Schaltfläche Einzelmodus
können Sie wechseln zwischen der Aktivierung
nur eines der Kategoriesymbole auf einmal (Einzelmodus) oder der Aktivierung mehrerer
Kategoriesymbole (Mehrfachmodus). In der Abbildung unten sehen Sie das
Autokomplettierungsfenster im Mehrfachmodus, d.h. alle Kategoriesymbole sind aktiviert.
Das Einzelmodussymbol ist deaktiviert.
Mit den Schaltflächen "Alle setzen / Zurücksetzen" können Sie alle
Kategorieeinstellungen setzen bzw. zurücksetzen.
Wenn die Autokomplettierung deaktiviert ist, drücken Sie Strg+ Leerzeichen, um das
Autokomplettierungsfenster bei Bedarf wieder anzuzeigen.
´
Filterkategorien:
Klasse, Schnittstelle, Primitivtyp, Datentyp, Enumeration, Klassenvorlage, Schnittstellen-Vorlage,
Datentyp-Vorlage.
Bitte beachten Sie:
Um die Autokomplettierung zu aktivieren/zu deaktivieren, wählen Sie Extras | Optionen |
Diagrambearbeitung (Register) und aktivieren Sie die Option "Automatische
Eingabehilfe aktivieren". Diese Einstellung hat keinen Einfluss auf die Funktion zum
Aufrufen des Autokomplettierungsfensters.
Altova UModel 2017
© 2016 Altova GmbH
Diagrammfenster
95
4.10.2 Ausschneiden, Kopieren und Einfügen in UModel Diagramme
Ausschneiden, Kopieren und Einfügen von Diagrammelementen im Diagrammfenster
Alle UModel Diagrammelemente können innerhalb desselben Typs, zwischen verschiedenen
Typen und selbst verschiedenen Diagrammarten ausgeschnitten, kopiert und eingefügt werden.
Dies erfolgt mit Hilfe der Maus oder mittels Tastaturkürzel und zwar auf zwei verschiedene Arten:
Nachdem Sie ein Element kopiert haben, gibt es folgende Möglichkeiten:
Sie können es "einfügen". Dies erfolgt mit Hilfe der Tastaturkürzel Strg+V, mit dem
Kontextmenübefehl "Einfügen" oder über den Befehl "Einfügen" aus dem Menü
"Bearbeiten". Dabei wird immer ein neues Modellelement zum Diagramm und zur
Modell-Struktur hinzugefügt.
Mit dem Kontextmenübefehl "Nur in Diagramm einfügen" (aufrufbar durch Rechtsklick
auf den Diagrammhintergrund) wird ein "Link/eine Ansicht" des bestehenden Elements
zum aktuellen Diagramm, nicht aber zur Modell-Struktur, hinzugefügt.
Hier ein Beispiel aus dem Klassendiagramm:
Einfügen (Strg+V) einer kopierten Klasse:
Durch Einfügen einer kopierten Klasse in dasselbe Diagramm (oder Paket) wird eine
neue Klasse mit dem Quellklassennamen plus einer Sequenznummer eingefügt. So
lautet der Name der Quellklasse z.B. myClass. Eingefügt wird der Klassenname
myClass1. Alle Operationen und Eigenschaften werden auch in die neue Klasse kopiert.
Durch Einfügen einer kopierten Klasse in ein anderes Paket wird ebenfalls eine neue
Klasse eingefügt, doch wird der ursprüngliche Klassenname beibehalten. In beiden Fällen
wird die neue Klasse auch zur Modell-Struktur hinzugefügt.
Einfügen (Strg+V) kopierter Eigenschaften oder Operationen:
Durch Einfügen einer Eigenschaft in dieselbe Klasse wird eine neue Eigenschaft mit
dem Namen der Quelleigenschaft sowie einer Sequenznummer eingefügt, also z.B.
MyProperty1.
Durch Einfügen einer Operation in dieselbe Klasse wird eine neue Operation mit
demselben Namen der Quelloperation eingefügt.
© 2016 Altova GmbH
Altova UModel 2017
96
Diagrammfenster
In beiden Fällen wird eine neue Eigenschaft/Operation zur Modell-Struktur hinzugefügt.
"Nur in Diagramm einfügen":
Wenn Sie diese Kontextmenüoption verwenden, wird im Diagramm, in das Sie das Element
einfügen ein "Link" zum bzw. eine "Ansicht" des Elements erstellt. Hier ein Beispiel aus dem
Klassendiagramm:
Mit dem Befehl "Nur in Diagramm einfügen" wird eine Ansicht der Ursprungsklasse
erstellt.
Die Klasse wird in das Diagramm eingefügt und genau wie die Quellklasse angezeigt.
Es wurde keine neue Klasse zur Modell-Struktur hinzugefügt!
Es wird keine Änderung am Klassennamen oder anderen Operationen/Eigenschaften
vorgenommen.
Wenn Sie die Eigenschaften des Elements in einer der "Ansichten" ändern, werden diese
auch in der anderen automatisch geändert.
Kopieren und Einfügen von Elementen mit der Maus:
1. Klicken Sie auf das gewünschte Modellelement.
2. Verschieben Sie den Mauszeiger an die Stelle, an die Sie das neue Element platzieren
möchten.
3. Halten Sie die Strg-Taste gedrückt. Unterhalb des Mauszeigers wird ein keines
Pluszeichen angezeigt, welches anzeigt, dass es sich hier um einen Kopiervorgang
handelt.
4. Lassen Sie die Maustaste los.
Altova UModel 2017
© 2016 Altova GmbH
Diagrammfenster
97
Es erscheint ein Popup-Menü, aus dem Sie einen der Befehle "Einfügen" oder "Nur in
Diagramm einfügen" auswählen können.
5. Wählen Sie die gewünschte Option aus.
Bitte beachten Sie:
Mit Hilfe der Maus und der Strg-Taste können Sie Eigenschaften und Operationen direkt
innerhalb einer Klasse kopieren oder verschieben.
© 2016 Altova GmbH
Altova UModel 2017
98
Hinzufügen/Einfügen von Modellelementen
4.11 Hinzufügen/Einfügen von Modellelementen
Es gibt mehrere Methoden, um Modellelemente zu erstellen und in Diagramme einzufügen:
Durch Hinzufügen der Elemente zu bestimmten Paketen in der Modell-Strukturansicht
Durch Ziehen von bestehenden Elementen vom Register "Modell-Struktur" auf das
Diagrammregister
Durch Klicken auf ein bestimmtes UML-Elementsymbol und Einfügen in das Diagramm
Durch Verwenden das Kontextmenüs, um Elemente zum Diagramm (und automatisch
zur Modell-Strukturansicht) hinzuzufügen.
Bitte beachten Sie, dass mehrere Elemente in der Modell-Strukturansicht entweder durch
Umschalt + Klick oder durch Strg + Klick ausgewählt werden können.
Hinzufügen von Elementen auf dem Register "Modell-Struktur"/"Favoriten":
Rechtsklicken Sie auf ein Paket, wählen Sie "Neu" und anschließend aus dem Menü,
das erscheint, das jeweilige Element.
Daraufhin wird das neue Element im aktuellen Projekt zum Register "Modell-Struktur"
hinzugefügt.
Einfügen von Elementen aus der Modell-Strukturansicht in ein Diagramm:
Modellelemente können einzeln eingefügt werden oder als Gruppe. Um mehrere Elemente zu
markieren, halten Sie die Strg-Taste gedrückt und klicken Sie auf die einzelnen Elemente. Zum
Einfügen der Elemente in das Diagramm stehen zwei verschiedene Methoden zur Verfügung: links
ziehen und rechts ziehen.
Links ziehen (normales Drop and Drop): Fügt Elemente direkt an der Cursorposition ein
(es werden automatisch alle Assoziationen, Abhängigkeiten, usw. die zwischen den
aktuell eingefügten und dem neuen Element bestehen, angezeigt).
Rechts ziehen (halten Sie die rechte Maustaste gedrückt und lassen Sie sie auf dem
Diagrammregister los): Öffnet ein Popup-Menü, aus dem Sie die Assoziationen,
Generalisierungen, die angezeigt werden sollen, auswählen können.
Beispiel:
Sie möchten das Diagramm "Account Hierarchy" in einem neuen Klassendiagramm replizieren.
1. Rechtsklicken Sie auf das bankview-Paket und wählen Sie Neu | Klassendiagramm.
2. Suchen Sie in der Modell-Struktur die abstrakte Klasse Account und verwenden Sie den
"Rechts ziehen"-Vorgang, um sie im neuen Diagramm zu platzieren.
Daraufhin wird das oben gezeigte Kontextmenü geöffnet.
3. Wählen Sie den Eintrag Einfügen mit Generalisierungshierarchie (spezifisch).
Altova UModel 2017
© 2016 Altova GmbH
Hinzufügen/Einfügen von Modellelementen
99
4. Deaktivieren Sie die Kontrollkästchen für die Elemente, die in den Elementen angezeigt
werden sollen (in diesem Fall für Eigenschaften und Operationen).
5. Klicken Sie auf OK.
Die Klasse "Account" und ihre drei Unterklassen werden alle auf dem
Diagrammregister eingefügt. Die Generalisierungspfeile werden automatisch angezeigt.
Hinzufügen von Elementen zu einem Diagramm mittels der Symbole in der
Symbolleiste:
1. Wählen Sie das jeweilige Element, das Sie einfügen möchten aus, indem Sie in der
Symbolleiste auf das dazugehörige Symbol klicken.
2. Klicken Sie auf das Diagrammregister, um das Element einzufügen.
Bitte beachten Sie:
Wenn Sie vor dem Klicken auf das Diagrammregister die Strg-Taste gedrückt halten,
können Sie mit den einzelnen Klicks in das Diagramm mehrere Elemente desselben
Typs einfügen.
Hinzufügen von Elementen zu einem Diagramm über das Kontextmenü:
Rechtsklicken Sie auf den Diagrammhintergrund und wählen Sie Neu | element name.
Bitte beachten Sie:
Beim Hinzufügen von neuen Elementen zum Diagrammregister wird dasselbe Element
automatisch zum Register "Modell-Struktur" hinzugefügt. Das Element wird zu dem
Paket hinzugefügt, das in der Modell-Strukturansicht das UML-Diagramm enthält.
Rechtsklicken Sie auf ein Element und wählen Sie Anzeigen | xx
Wenn Sie z.B. auf die Klasse "Account" rechtsklicken und den Eintrag Anzeigen |
Generalisierungshierarchie wählen, werden die abgeleiteten Klassen ebenfalls in das
Diagramm eingefügt.
© 2016 Altova GmbH
Altova UModel 2017
100
Verknüpfen von Modellierungselementen
4.12 Verknüpfen von Modellierungselementen
UModel unterstützt nun das automatische und manuelle Verknüpfen von Modellierungselementen
mittels Hyperlink. Die Hyperlinks werden automatisch erstellt, wenn Sie beim Importieren von
Quellcode oder Binärdateien in ein Modell die entsprechende Option auswählen.
Die Erstellung von manuellen Hyperlinks wird zwischen den meisten Modellierungselementen
(ausgenommen Linien) und:
jedem Diagram im aktuellen ump-Projekt
jedem Element in einem Diagramm
jedem Element in der Modellstruktur
externen Dokumenten, z.B. PDF-, Excel- oder Word-Dokumenten
Webseiten
unterstützt.
Anmerkung:
Alle manuell erstellten Hyperlinks stehen bei Generierung von UML-Dokumentation auch
in der HTML-Projektdokumentation zur Verfügung.
Wenn Sie das Bank Server-Diagramm unter dem Paket "Bank Server" öffnen, wird die IBankAPISchnittstelle sowie die BankServer-Klasse angezeigt. Auch ein Enumerationselement, das die
Namen der EnumerationLiterals enthält, ist zu sehen. Wir möchten nun einen Hyperlink von
Enumeration zu Account Hierarchy-Klassendiagramm erstellen.
So erstellen Sie einen Hyperlink zu einem Diagramm:
1. Rechtsklicken Sie auf das Element und wählen Sie die Option Hyperlinks | Hyperlinks
einfügen/bearbeiten.
Altova UModel 2017
© 2016 Altova GmbH
101
Daraufhin wird das Dialogfeld "Hyperlinks bearbeiten" geöffnet. Hier werden die Hyperlinks
verwaltet.
2. Klicken Sie auf die Schaltfläche hinzufügen, und wählen Sie die Option DiagrammLink, um einen Link zu einem bestehenden Diagramm zu definieren.
3. Wählen Sie das Ziel des Hyperlinks aus, zu dem navigiert werden soll, z.B. Hierarchy of
Account diagram, und klicken Sie auf OK.
Wenn Sie in die Spalte "benutzerdefinierter Name" doppelklicken, können Sie Ihren
eigenen Link-Namen definieren.
Beachten Sie: Sie können mehrere und auch verschiedene Arten von Links von einem
einzigen Modellierungselement aus hinzufügen, z.B. können Sie über die Schaltfläche
Hinzufügen | Web Link einen Web Link zu http://altova.com/support_help.html
hinzufügen.
© 2016 Altova GmbH
Altova UModel 2017
102
4. Klicken Sie auf OK, sobald Sie alle Ihre Hyperlinks definiert haben.
Links oben wurde nun ein Link-Symbol zum Enumeration-Element hinzugefügt. Wenn Sie
den Mauscursor über das Link-Symbol platzieren, erscheint ein Popup mit dem Namen
des Target-Elements.
Hyperlinks in Operationen
Hyperlinks von einer Eintrittsaktion in einem Zustandsdiagramm
So erstellen Sie einen Link zu einem bestimmten Diagrammelement (Diagrammlink):
1. Erstellen Sie den Hyperlink, wie zuvor beschrieben, klicken Sie jedoch auf das +-Zeichen,
um den Inhalt des Diagramms erweitert anzuzeigen.
Altova UModel 2017
© 2016 Altova GmbH
103
2. Wählen Sie das jeweilige Modellierungselement, zu dem Sie einen Link erstellen
möchten, und klicken Sie auf OK.
Wenn Sie auf das Link-Symbol klicken, wird das jeweilige Diagramm geöffnet, wobei das
Element sichtbar und ausgewählt ist.
So erstellen Sie einen Link zu einem Element in der Modell-Struktur (Modell-Link):
Gehen Sie vor, wie oben beschrieben. Klicken Sie aber im Dialogfeld auf den Befehl
hinzufügen | Modell-Link.
Wenn Sie auf den Link klicken, sobald er eingefügt wurde, werden Sie zum dem Element
geführt, das Sie im Dialogfeld in der Modell-Struktur ausgewählt haben.
Anmerkung: Beim Generieren von Projektdokumentation werden die Hyperlinks zu den
Modellelementen in der Modell-Struktur angepasst, sodass sie in der generierten
Dokumentation auf die richtigen Definitionen verweisen.
So erstellen Sie einen Link zu einem Dokument:
1. Klicken Sie im Dialogfeld "Hyperlinks bearbeiten" auf die Schaltfläche Hinzufügen |
Datei-Link .
2. Wählen Sie das Dokument aus, zu dem Sie einen Link erstellen möchten, z.B. *.doc,
*.xls, *.pdf, usw.
So erstellen Sie von einer Anmerkung einen Hyperlink:
1. Wählen Sie den Text in der Anmerkung aus, indem Sie auf ein Wort klicken oder es mit
der Maus ziehen.
2. Rechtsklicken Sie auf den ausgewählten Text und wählen Sie die Menüoption Hyperlinks
einfügen/bearbeiten.
3. Erstellen Sie über das Dialogfeld "Hyperlinks bearbeiten" einen Link zu einem Diagramm.
© 2016 Altova GmbH
Altova UModel 2017
104
Bitte beachten Sie:
Auf dieselbe Art können Sie auch Hyperlinks von Kommentarelementen aus erstellen.
So erstellen Sie einen Link vom Register "Dokumentation":
1. Geben Sie auf dem Register "Dokumentation" den erklärenden Text ein.
2. Wählen Sie aus, welcher Text, als Link verwendet werden soll.
3. Klicken Sie auf die rechte Maustaste und wählen Sie aus, welcher Link erstellt werden
soll.
So navigieren Sie zum Ziel eines Hyperlinks:
1. Klicken Sie auf das Hyperlink-Symbol im Modellierungselement.
Wenn nur ein Ziel definiert ist, wird das Zieldiagramm, die Website usw. sofort angezeigt.
Wenn mehrere Ziele definiert wurden, erscheint ein Popup-Dialogfeld, in dem Sie eines
der verfügbaren Ziele auswählen können.
Wenn Sie auf den ersten Eintrag klicken, wird das Hierarchy of Account-Diagramm
geöffnet.
Navigieren von Hyperlinks:
Klicken Sie in der Hauptsymbolleiste auf die Symbole "Vorheriges"
"Nächstes"
und
um zur Quelle und zum Ziel zu navigieren.
So bearbeiten/ändern Sie einen Hyperlink:
1. Rechtsklicken Sie auf das Link-Symbol und wählen Sie den Eintrag Hyperlinks
einfügen, bearbeiten oder entfernen.
2. Über das Dialogfeld "Hyperlinks bearbeiten" können Sie Ihre Hyperlinks verwalten.
Altova UModel 2017
© 2016 Altova GmbH
© 2016 Altova GmbH
105
Altova UModel 2017
106
Bank-Beispieldateien
4.13 Bank-Beispieldateien
Der Ordner ...\UModelExamples enthält Dateien mit Beispielen zu verschiedenen Aspekten der
UML-Modellierung in UModel. Sie sind so ausgelegt, dass Modelle für die Programmiersprachen
Java und C# sowie eine Kombination beider Sprachen in einem Modellierungsprojekt zu sehen
sind.
In der Abbildung unten sehen Sie die Datei Bank_Java.ump:
das Java-Profil wurde dem Paket "Bankview" zugewiesen
die Java-Namespace Root wurde den Paketen "Banking access" und "BankView"
zugewiesen.
das Paket "Interaction View" enthält zwei Interaction-Elemente, von denen jedes ein
Sequenzdiagramm enthält.
In der Abbildung unten sehen Sie die Datei Bank_CSharp.ump:
das C#-Profil wurde dem Paket BankView zugewiesen
die C# Namespace Root wurde den Paketen "Banking access" und "BankView"
zugewiesen.
Altova UModel 2017
© 2016 Altova GmbH
Bank-Beispieldateien
107
In der Abbildung unten sehen Sie die Datei Bank_MultiLanguage.ump:
das Java-Profil wurde dem Paket "BankView" zugewiesen
die C# Namespace Root wurde dem Paket "Bank Server" zugewiesen
die Java Namespace Root wurde dem Paket "BankView" zugewiesen.
das Projekt wurde in 4 editierbare Unterprojekte, nämlich Bank Server.ump, Banking
access.ump, BankView.ump und Bank_Multilanguage_Use Case View.ump aufgeteilt.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 5
110
5
Zusätzlich zur grafischen Benutzeroberfläche verfügt UModel auch über eine
Befehlszeilenschnittstelle. Um die Befehlszeilenschnittstelle aufzurufen, führen Sie die Datei
UModelBatch.exe aus dem Ordner C:\Programme\Altova\UModel2017 aus. Wenn Sie die
UModel 32-Bit-Version auf einem 64-Bit-Betriebssystem ausführen, so lautet der Pfad C:
\Programme (x86)\Altova\UModel2017.
Die Befehlszeilenparametersyntax wird unten gezeigt und kann im Fenster zur Befehlseingabe
angezeigt werden, wenn Sie eingeben: umodelbatch /?
Hinweis: Wenn der Pfad oder Dateiname Leerzeichen enthält, setzen Sie den Pfad/Dateinamen
bitte in Anführungszeichen, d.h. "c:\Programme\...\Dateiname"
usage: umodelbatch [project] [options]
/? oder /help ... diese Hilfeinformationen anzeigen
Projekt
...
Optionen
/new[=Datei]...
speichern
/set
...
/gui
...
Projektdatei (*.ump) siehe auch Datei: New/Load/Saveneues Projekt erstellen/speichern/unter einem neuen Namen
Optionen permanent festlegen
UModel-Benutzeroberfläche anzeigen
Befehle (in der angeführten Reihenfolge ausgeführt):
/chk
... Projektsyntax überprüfen
/isd=Pfad
... Quellverzeichnis importieren
/isp=Datei ... Quellprojektdatei importieren
(*.project,*.xml,*.jpx,*.csproj,*.csdproj,*.vbproj,*.vbdproj,*.sln,*.bdspro
j)
/ibt=Liste ... Binärtypen importieren (Liste der Binär[Typnamen]
definieren)
(';'=Trennzeichen, '*'=alle Typen, '#' vor Assembly-Namen)
/ixd=Pfad
... XML-Schemaverzeichnis importieren
/ixs=Datei ... XML-Schemadatei importieren (*.xsd)
/m2c
... Programmcode anhand von Modell aktualisieren (exportieren/
Forward Engineering)
/c2m
... Modell anhand von Programmcode aktualisieren (importieren/
Reverse Engineering)
/ixf=Datei ... XMI-Datei importieren
/exf=Datei ... XMI-Datei exportieren
/inc=Datei ... Datei inkludieren
/mrg=Datei ... Datei zusammenführen
/doc=Datei ... Dokumentation in angegebene Datei schreiben
/lue[=cpri] ... alle Elemente auflisten, die in keinem Diagramm verwendet
werden (d.h. nicht verwendete)
/ldg
... alle Diagramme auflisten
/lcl
... alle Klassen auflisten
/lsp
... alle freigegebenen Pakete auflisten
/lip
... alle inkludierten Pakete auflisten
Optionen zum Speichern als neues Projekt:
Altova UModel 2017
© 2016 Altova GmbH
/npad=opt
111
... relative Dateipfade anpassen (Yes | No | MakeAbsolute)
Optionen für Import-Befehle:
/iclg[=lang ... Codesprache (Java1.4 | Java5.0 | Java6.0 | C#1.2 | C#2.0 |
C#3.0 | C#4.0 | C#5.0 | C#6.0 | VB7.1 | VB8.0 |VB9.0)
/ipsd[=0|1] ... Unterverzeichnisse verarbeiten (rekursiv)
/irpf[=0|1] ... relativ zur UModel-Projektdatei importieren
/ijdc[=0|1] ... JavaDocs als Java-Kommentare
/icdc[=0|1] ... DocComments als C#-Kommentare
/icds[=lst] ... C# definierte Symbole
/ivdc[=0|1] ... DocComments als VB-Kommentare
/ivds[=lst] ... VB-definierte Symbole (benutzerdefinierte Konstanten)
/imrg[=0|1] ... zusammengeführte synchronisieren
/iudf[=0|1] ... Verzeichnisfilter verwenden
/iflt[=lst] ... Verzeichnisfilter (Voreinstellungen /iudf)
Optionen für den Import von Binärtypen (nach /iclg):
/ibrt=vers ... Runtime Version
/ibpv=Pfad ... Variable PATH zum Durchsuchen von nativen Code-Bibliotheken
außer Kraft setzen
/ibro[=0|1] ... nur Reflection-Kontext verwenden
/ibua[=0|1] ... hinzugefügte referenzierte Typen mit Paketfilter verwenden
/ibar[=flt] ... referenzierte Typpaketfilter hinzufügen (presets /ibua)
/ibot[=0|1] ... nur Typen importieren
/ibuv[=0|1] ... Mindestsichtbarkeitsfilter verwenden
/ibmv[=key] ... Schlüsselwort der erforderlichen Mindestsichtbarkeit
(presets /ibuv)
/ibsa[=0|1] ... Attributabschnitte / Annotations-Modifier unterdrücken
/iboa[=0|1] ... nur ein Attribut pro Attributabschnitt erstellen
/ibss[=0|1] ... 'Attribute'-Suffix bei Attributtypnamen unterdrücken
Optionen für die Diagrammgenerierung:
/dgen[=0|1] ... Diagramme generieren
/dopn[=0|1] ... generierte Diagramme öffnen
/dsac[=0|1] ... Attributbereich anzeigen
/dsoc[=0|1] ... Operation-Bereich anzeigen
/dscc[=0|1] ... Bereiche für geschachtelte Classifier anzeigen
/dstv[=0|1] ... Eigenschaftswerte anzeigen
/dudp[=0|1] ... .NET-Eigenschaftsbereich verwenden
/dspd[=0|1] ... .NET-Eigenschaftsbereich anzeigen
Optionen für Export-Befehle:
/ejdc[=0|1] ... Java-Kommentare als JavaDocs
/ecdc[=0|1] ... C#-Kommentare als DocComments
/evdc[=0|1] ... VB-Kommentare als DocComments
/espl[=0|1] ... benutzerdefinierte SPL-Vorlagen verwenden
/ecod[=0|1] ... gelöschte auskommentieren
/emrg[=0|1] ... zusammengeführte synchronisieren
/egfn[=0|1] ... fehlende Dateinamen generieren
/eusc[=0|1] ... Syntaxüberprüfung verwenden
Optionen für den XMI-Export:
/exid[=0|1] ... UUIDs exportieren
© 2016 Altova GmbH
Altova UModel 2017
112
/exex[=0|1] ... UModel-spezifische Erweiterungen exportieren
/exdg[=0|1] ... Diagramme exportieren (presets /exex)
/exuv[=ver] ... UML-Version (UML2.0 | UML2.1.2 | UML2.2 | UML2.3 | UML2.4)
Optionen für die Dateizusammenführung:
/mcan=Datei ... gemeinsame Vorgängerdatei
Optionen für die Dokumentationsgenerierung:
/doof=fmt ... Ausgabeformat (HTML | RTF | MSWORD | PDF )
/dsps=Datei
...SPS-Designdatei
Im Abschnitt "Projekt":
Der Parameter /new definiert den Pfad und Namen der neuen Projektdatei (*.ump). Sie
können diesen Parameter auch verwenden, um ein bestehendes Projekt unter einem
anderen Namen zu speichern, z.B. UmodelBatch.exe MyFile.ump /
new=MyBackupFile.ump. Siehe auch Datei: New/Load/Save-Optionen
Der Parameter /set überschreibt die aktuellen Standardeinstellungen in der
Registrierungsdatei, wobei die Optionen/Einstellungen hier definiert werden.
Der Parameter /gui zeigt die UModel-Benutzeroberfläche bei der Batchverarbeitung an.
Beispiel 1
Der folgende Befehl importiert Quellcode und erstellt eine neue Projektdatei. Beachten Sie, dass
der Projektpfad Leerzeichen enthält und innerhalb von Anführungszeichen steht.
"C:\Program Files\Altova\UModel2017\UModelBatch.exe" /new="C:\Program Files
\Altova\UModel2017\UModelBatchOut\Fred.ump" /isd="X:TestCases\UModel\Fred" /
set /gui /iclg=Java5.0 /ipsd=1 /ijdc=1 /dgen=1 /dopn=1 /dmax=5 /chk
/new:
Gibt an, dass die neu erstellte Projektdatei den Namen "Fred.ump" erhalten und
unter C:\Program Files\Altova\U M odel2017\UModelBatchOut\ erstellt werden
soll
/isd=
Gibt an, das das Root-Verzeichnis, in das importiert werden soll "X:\TestCases
\UModel\Fred" sein soll.
/set:
Gibt an, dass alle in der Befehlszeile verwendeten Optionen in der
Registrierungsdatei gespeichert werden sollen (Wenn UModel anschließend
gestartet wird, werden diese Einstellungen die Standardeinstellungen).
/gui:
die UModel-GUI bei der Batch-Verarbeitung anzeigen
/iclg:
UModel importiert den Code als Java5.0
/ipsd=1:
alle im Parameter /isd definierten Unterverzeichnisse des Root-Verzeichnisses
rekursiv verarbeiten
/pfd=1:
für jedes importierte Verzeichnis im UModel-Projekt Pakete erstellen
/ijdc=1:
gegebenenfalls JavaDoc anhand von Kommentaren erstellen
/dgen=1:
Diagramme generieren
/dopn=1:
generierte Diagramme öffnen
Altova UModel 2017
© 2016 Altova GmbH
/dmax=5:
maximal fünf Diagramme öffnen
/chk:
Syntaxüberprüfung durchführen
113
Beispiel 2
Der folgende Befehl importiert Quellcode aus X:\TestCases\UModel und speichert die erzeugte
Projektdatei unter C:\Program Files\Altova\UModel2017\UModelBatchOut\finalclass.ump.
"C:\Program Files\Altova\UModel2017\UModelBatch.exe" /new="C:\Program Files
\Altova\UModel2017\UModelBatchOut\finalclass.ump" /isd="X:\TestCases\UModel
\" /iclg=Java5.0 /ipsd=1 /ijdc=1 /dgen=1 /dopn=1 /dmax=5 /dsat=1 /dsnc=1 /chk
/dsat=1
Attribute in den generierten Diagrammen unterdrücken
/dsnc=1
geschachtelte Classifier in den generierten Diagrammen unterdrücken
Beispiel 3
Der folgende Befehl synchronisiert Code mit einer vorhandenen Projektdatei ("C:\Program Files
\Altova\UModel2017\UModelBatchOut\Fred.ump").
"C:\Program Files\Altova\UModel2017\UModelBatch.exe" "C:\Program Files\Altova
\UModel2017\UModelBatchOut\Fred.ump" /m2c /ejdc=1 /ecod=1 /emrg=1 /egfn=1 /
eusc=1
/m2c
Code anhand von Modell aktualisieren
/ejdc:
Kommentare im Projektmodell sollen als JavaDoc generiert werden
/ecod=1:
gelöschten Code auskommentieren
/emrg=1
zusammengeführten Code synchronisieren
/egfn=1:
fehlende Dateinamen im Projekt generieren
/eusc=1
Syntaxüberprüfung verwenden
© 2016 Altova GmbH
Altova UModel 2017
114
5.1
Datei: New / Load / Save-Optionen
Vollständiger Batch-Modus, d.h. der /gui-Parameter wird nicht verwendet.
new
UModelBatch /new=xxx.ump (options)
Erstellt ein neues Projekt, führt die Optionen aus, xxx.ump wird immer (unabhängig von
den Optionen) gespeichert
auto save
UModelBatch xxx.ump (options)
Lädt das Projekt xxx.ump, führt die Optionen aus, xxx.ump wird nur dann gespeichert,
wenn sich das Dokument geändert hat (wie /ibt)
save
UModelBatch xxx.ump (options) /new
Lädt das Projekt xxx.ump, führt die Optionen aus, xxx.ump wird immer gespeichert
(unabhängig von den Optionen)
save as
UModelBatch xxx.ump (options) /new=yyy.ump
Lädt das Projekt xxx.ump, führt die Optionen aus, speichert xxx.ump immer als yyy.ump
(unabhängig von den Optionen)
Batch-Modus, wobei die UModel-Benutzeroberfläche sichtbar bleibt, d.h. der /gui Parameter
wird verwendet.
new
UModelBatch /gui /new (options)
Erstellt ein neues Projekt, führt die Optionen aus, nichts wird gespeichert, die GUI bleibt
offen
save new
UModelBatch /gui /new=xxx.ump (options)
Erstellt ein neues Projekt, führt die Optionen aus, xxx.ump wird gespeichert, die GUI
bleibt offen
user mode
UModelBatch /gui xxx.ump (options)
Lädt das Projekt xxx.ump, führt die Optionen aus, nichts wird gespeichert, die GUI bleibt
offen
save
UModelBatch /gui xxx.ump (options) /new
Lädt das Projekt xxx.ump, führt die Optionen aus, xxx.ump wird gespeichert, die GUI
bleibt offen
save as
UModelBatch /gui xxx.ump (options) /new=yyy.ump
Lädt das Projekt xxx.ump, führt die Optionen aus, speichert xxx.ump als yyy.ump, die
GUI bleibt offen
Altova UModel 2017
© 2016 Altova GmbH
115
Das Projekt wird erfolgreich gespeichert, wenn bei Ausführung der Optionen kein
schwerwiegender Fehler auftritt.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 6
118
6
Alle Java-spezifischen Konstrukte werden nun in UModel unterstützt, unter
anderem:
Java Annotationen
Attribute, Operationen und geschachtelte Qualifier für EnumerationLiterals
Enumerationen können Schnittstellen realisieren
NetBeans Projektdateien
Reverse Engineering unterstützt jetzt:
die Möglichkeit ein einziges Diagramm für alle mit Reverse Engineering generierten
Elemente zu erzeugen.
die Möglichkeit, anonyme gebundene Elemente in Diagrammen ein- und auszublenden
die Möglichkeit, während des Imports automatisch Hyperlinks von Paketen zu den
entsprechenden Paket-Inhaltsdiagrammen anzulegen.
die Möglichkeit Aliasse aufzulösen.
das Schreiben von Unicode-Zeichen in neue Quellcodedateien
das Erstellen von Assoziationen anhand von .NET-Eigenschaften
So erstellen Sie ein neues Projekt:
1. Klicken Sie in der Symbolleiste auf das Symbol Neu (oder wählen Sie den Menübefehl
Datei | Neu).
Die Root Component-Pakete werden automatisch eingefügt, wenn ein neues Projekt erstellt wird,
und auf dem Register "Modell-Struktur" angezeigt. Es wird ein neues Projekt mit dem
Standardnamen NeuesProjekt1 erstellt. Beachten Sie, dass beim Start von UModel automatisch
ein neues Projekt geöffnet wird.
Ein neu erstelltes UModel-Projekt besteht aus den folgenden Paketen:
Root-Paket und
Component View-Paket
Diese beiden Pakete sind die einzigen, die nicht umbenannt oder gelöscht werden
können.
Alle projektrelevanten Daten werden in der UModel-Projektdatei gespeichert. Diese Datei hat die
Altova UModel 2017
© 2016 Altova GmbH
119
Erweiterung *.ump. Jedes Ordnersymbol auf dem Register "Modell-Struktur" stellt ein UML-Paket
dar!
UModel-Projektarbeitsablauf:
UModel zwingt Sie nicht, sich bei der Modellierung an eine bestimmte vordefinierte Reihenfolge zu
halten!
Sie können jeden Modellelementtyp zum Projekt hinzufügen: UML-Diagramm, Paket, Akteur usw.
- und zwar in jeder beliebigen Reihenfolge bzw. and jeder beliebigen Stelle; Beachten Sie, dass
alle Modellelemente direkt auf dem Register "Modell-Struktur" eingefügt, umbenannt und gelöscht
werden können, d.h. Sie müssen diese Elemente nicht unbedingt als Teil eines Diagramms
erstellen.
So fügen Sie ein neues Paket ein:
1. Rechtsklicken Sie auf das Paket, unter dem das neue Paket angezeigt werden soll, also
in einem neuen Projekt entweder "Root" oder "Component View".
2. Wählen Sie Neu | Paket.
Unterhalb des bestehenden Pakets wird ein neues Paket erstellt. Das Namensfeld wird
automatisch markiert, sodass Sie sofort den Paketnamen eingeben können.
Pakete sind die Behälter für alle anderen UML-Modellierungselemente, Use CaseDiagramme, Klassen, Instanzen usw.
Pakete können an jeder Stelle in der Modell-Struktur erstellt werden.
Pakete/Inhalt können/kann in andere Pakete in der Modell-Struktur (sowie in gültige
Modell-Diagramme auf dem Diagrammregister) verschoben/kopiert werden.
Pakete und deren Inhalt können (auf dem Register "Modell-Struktur") nach verschiedenen
Kriterien sortiert werden.
Pakete können innerhalb von anderen Paketen platziert werden.
Pakete können beim Zusammenführen oder Synchronisieren von Code als Quell- oder
Zielelemente verwendet werden.
Damit Elemente in einem UML-Diagramm angezeigt werden, müssen Sie:
1. ein neues UML-Diagramm einfügen. Rechtsklicken Sie dazu und wählen Sie Neu |
(Klassen)diagramm.
2. ein bestehendes Modellelement aus der Modell-Struktur in ein neu erstelltes Diagramm
ziehen oder
3. neue Elemente direkt über das Kontextmenü in der Diagrammansicht hinzufügen.
So speichern Sie ein Projekt:
Wählen Sie die Menüoption Datei | Speichern unter... (oder Datei | Speichern). Anmerkung:
Über Extras | Optionen | Datei (Register) können Sie festlegen, dass die *.ump-Datei beim
Speichern in einem "Pretty-Print"-Format gespeichert wird.
So öffnen Sie ein Projekt:
Wählen Sie die Menüoption Datei | Öffnen oder wählen Sie eine Datei in der Dateiliste aus.
Bitte beachten Sie:
Externe Änderungen, die an der Projektdatei oder inkludierten Dateien vorgenommen
wurden, werden automatisch erkannt und es erscheint eine entsprechende Meldung. Sie
können auswählen, ob das Projekt neu geladen werden soll oder nicht.
So verschieben Sie ein Projekt:
UModel-Projekte und generierter Code können ganz einfach in ein anderes Verzeichnis (oder auf
© 2016 Altova GmbH
Altova UModel 2017
120
einen anderen Computer) verschoben und dort erneut synchronisiert werden.
Dazu gibt es zwei Methoden:
Wählen Sie die Menüoption Datei | Speichern unter... und klicken Sie auf Ja, wenn Sie
gefragt werden, ob die Dateipfade an den neuen Projektordner angepasst werden sollen.
Kopieren Sie das UModel-Projekt (*.ump) in einen neuen Ordner und passen Sie die
Pfade der Codegenerierungspakete in der Komponentendiagrammansicht an das neue
Verzeichnis an.
z.B. bei Verwendung von BankMultilanguage.ump:
1. Öffnen Sie das Komponentendiagramm "Overview" und klicken Sie auf die Komponente
"BankView".
2. Aktualisieren Sie den Eintrag im Feld Verzeichnis, und geben Sie dort den neuen Pfad
an.
3. Synchronisieren Sie das Modell erneut mit dem Code.
Altova UModel 2017
© 2016 Altova GmbH
6.1
Mini-UModel Projekt - von Grund auf neu erstellen
121
In diesem Abschnitt werden die Schritte beschrieben, die nötig sind, um ein Projekt von Grund auf
neu zu erstellen und Code für eine einzige Klasse zu generieren. Hier wird anhand eines MiniProjekts jedoch unter Verwendung mehrerer Diagramme gezeigt, wie man Methoden hinzufügt
usw. Alle diese Aktionen könnten auch nur unter Verwendung des Registers "Modell-Struktur"
durchgeführt werden. Zur Erstellung von Klassen oder Methoden werden keine
Modellierungsdiagramme benötigt.
Erstellen eines neuen Projekts und Definieren der Namespace Root
Führen Sie im UModel-Fenster "Modell-Struktur" folgende Schritte durch:
1. Wählen Sie Datei | Neu, um ein neues Modellierungsprojekt zu erstellen.
2. Rechtsklicken Sie auf das Root-Paket und wählen Sie Neues Element | Paket. Geben
Sie dem Paket z.B. den Namen MyPackage.
3. Rechtsklicken Sie auf "MyPackage" und wählen Sie Code Engineering | Als Java
Namespace Root definieren und klicken Sie auf OK, um das UModel Java Profil auf
das Paket anzuwenden.
Daraufhin wird ein Java-Profilpaket zur Modell-Struktur hinzugefügt.
Inkludieren von Java Lang für JDK-Datentypen
1. Rechtsklicken Sie auf das Root-Paket und wählen Sie Projekt | Unterprojekt
inkludieren.
2. Klicken Sie auf das Register "Java 1.4" und wählen Sie das Paket Java Lang.ump aus.
Klicken Sie auf OK, um die Standardoption "Durch Referenz:" zu verwenden.
Daraufhin werden ein Java Lang-Paket und ein Paket "Unknown Externals" zur ModellStruktur hinzugefügt.
Erstellen der Klasseneigenschaften und Methoden
1. Rechtsklicken Sie auf MyPackage und wählen Sie die Option Neues Diagramm |
Klassendiagramm.
© 2016 Altova GmbH
Altova UModel 2017
122
2. Rechtsklicken Sie in das Klassendiagramm und wählen Sie Neu | Klasse, um im
Diagramm eine neue Klasse zu erstellen z.B. MyClass.
3. Drücken Sie F7 und fügen Sie einige Attribute hinzu, z.B. UserName:String und
Password:String.
4. Drücken Sie F8 und fügen Sie einige Optionen hinzu, z.B. GetUserName():String und
GetPassword():String.
Erstellen einer Komponente und Definieren des Code-Verzeichnisses
1. Rechtsklicken Sie auf das Paket Component View und fügen Sie ein neues
Komponentendiagramm hinzu.
2. Ziehen Sie das Klassenelement MyFirstClass aus der Modellstruktur in das
Komponentendiagramm.
3. Fügen Sie eine neue Komponente zum Diagramm hinzu z.B. MyComponent.
Altova UModel 2017
© 2016 Altova GmbH
123
4. Klicken Sie auf die Komponente im Diagramm, um sie auszuwählen, und klicken Sie
anschließend auf das Feld Verzeichnis im Fenster "Eigenschaften" und geben Sie das
Verzeichnis ein, in dem der Code gespeichert werden soll, z.B. C:\MyCode.
Realisieren der Klasse
1. Klicken Sie auf MyFirstClass und ziehen Sie den Ziehpunkt
"Komponentenrealisierung" am unteren Rand des Elements auf die neue Komponente
MyComponent.
Eine Klasse muss "realisiert" werden, bevor Code generiert werden kann. Beachten Sie,
dass Sie die Klasse auch direkt in der Modell-Struktur auf die Komponente ziehen
könnten.
Syntaxüberprüfung und Generierung von Code
1. Wählen Sie die Option Projekt | Projektsyntax überprüfen, um zu überprüfen, ob alles
in Ordnung ist.
© 2016 Altova GmbH
Altova UModel 2017
124
Es werden null Fehler und eine Warnung generiert. Obwohl der Codename vorher nicht
definiert wurde, wird automatisch ein Standardname generiert.
2. Wählen Sie Projekt | Merge Programmcode aus UModel-Projekt um Java-Code
auszugeben/zu generieren.
Erstellen eines Namespace
Wenn Sie die Klasse innerhalb eines bestimmten Namespace erstellen möchten:
1. Fügen Sie unterhalb von myPackage ein neues Paket hinzu, z.B. altova.
2. Klicken Sie auf das Paket und aktivieren Sie das Kontrollkästchen <<namespace>> im
Fenster "Eigenschaften".
Altova UModel 2017
© 2016 Altova GmbH
125
3. Verschieben Sie die Klasse "MyFirstClass" im Fenster "Modell-Struktur" in das Paket
"altova".
Die Klasse befindet sich nun bei Generierung von Code im Namespace altova.
© 2016 Altova GmbH
Altova UModel 2017
126
Importieren von Quellcode in Projekte
6.2
Quellcode kann als Quellprojekt oder als Quellverzeichnis importiert werden. Ein Beispiel dazu
finden Sie im Tutorial unter Round-Trip Engineering (Code - Modell - Code).
JBuilder .jpx, Eclipse .project Projektdateien sowie NetBeans (project.xml) werden
derzeit unterstützt..
C#-Projekte / Visual Basic-Projekte (Visual Studio- sln, csproj, csdprj..., vbproj, vbp
sowie Borland .bdsproj Projektdateien)
So importieren Sie bestehenden Code in UModel:
1. Wählen Sie Projekt | Quellprojekt importieren.
2. Klicken Sie auf das Durchsuchen-Symbol
im Dialogfeld "Quellprojekt importieren".
3. Wählen Sie den Projektdateityp aus, z.B. .jpx und klicken Sie auf "Öffnen". Sie finden
die diese JBuilder-Projektdatei in der Datei OrgChart.zip im Ordner ...\UModelExamples.
Beachten Sie, dass die Option zum Importieren des Projekts relativ zur UModelProjektdatei aktiv ist. Damit UModel Klassen- und Paketdiagramme generiert, aktivieren
Sie das Kontrollkästchen "Diagrammgenerierung aktivieren" und klicken Sie
anschließend auf "Weiter".
4. Aktivieren Sie das Kontrollkästchen "In neues Paket importieren" (oder klicken Sie im
Fester "Importziel" auf das entsprechende Paket).
Altova UModel 2017
© 2016 Altova GmbH
127
5. Wenn Sie dazu aufgefordert werden, aktivieren Sie die Optionen Einzelnes Diagramm
generieren und/oder Diagramm pro Paket generieren. Die Stile für das Diagramm
können gegebenenfalls später geändert werden.
6. Klicken Sie zum Fortfahren auf "Weiter".
In diesem Dialogfeld können Sie die Einstellungen für die Generierung von
Paketabhängigkeiten definieren.
© 2016 Altova GmbH
Altova UModel 2017
128
7. Klicken Sie auf "Fertig stellen", um die Standardeinstellungen zu verwenden. Das Projekt
wird geparst und das UModel-Modell wird generiert.
Bitte beachten Sie:
Altova UModel 2017
© 2016 Altova GmbH
129
Beim Import in ein bestehendes Projekt werden Sie gefragt, in welches Paket es
importiert werden soll. Wenn Sie ein neues Projekt verwenden, wird der Ordner
"OrgChart" automatisch erstellt.
Auflösen von Aliassen:
Beim Reverse Engineering von Code, der Namespace- oder Klassenaliasse enthält, können Sie
nun auswählen, ob der Alias aufgelöst werden soll (Kontrollkästchen "Aliasse auflösen" im
Dialogfeld "Quellprojekt/Verzeichnis importieren").
Wenn Code aktualisiert wird, d.h. wenn Code anhand des Modells aktualisiert wird, werden AliasDefinitionen im Code unverändert beibehalten. Der Geltungsbereich der Aliasdefinitionen sind die
Dateien, in denen diese vorkommen.
z.B.
using Q = System.Collections.Generic.Queue<String>;
Q myQueue;
Alle Aliasse, bei denen es zu einem Konflikt kommen könnte, werden zu den "unbekannten
externen Elementen" hinzugefügt, wenn ihre Verwendung nicht eindeutig ist.
Anmerkung:
Die Einstellung "Aliasnamen auflösen" kann jederzeit im Dialogfeld "Projekteinstellungen"
geändert werden.
Definierte Symbole
In C#- oder Visual Basic-Code können Sie eine Liste von "definierten Symbolen" in das
gleichnamige Feld eingeben. Mit Hilfe dieser Anweisungen können Sie Codeabschnitte bei
Zutreffen bestimmter Bedingungen kompilieren. Geben Sie diese Anweisungen in Form einer
durch Semikola getrennten Liste ein. Code, der nicht in diese Anweisungen eingeschlossen ist,
wird auskommentiert.
UModel gibt alle im Quellcode verwendeten Symbole im Fenster "Meldungen" aus, sobald das
Reverse Engineering abgeschlossen ist.
Z.B. #If DEBUG Then
Dim i = 10
#Else
dim a = 20
#End If
Ausnahmeereignisse
Wenn Sie in einer der Klassen auf eine Operation klicken und anschließend auf das
Dropdown-Listenfeld Exception werden die Informationen zum Ausnahmeereignis
angezeigt, das eine Operation auslösen kann.
© 2016 Altova GmbH
Altova UModel 2017
130
Altova UModel 2017
© 2016 Altova GmbH
6.3
Importieren von Java-, C#- und VB-Binärdateien
131
UModel unterstützt den Import von C#-, Java- und VB-Binärdateien. Diese Funktion erweist sich
vor allem beim Arbeiten mit Binärdateien aus externen Quellen oder, wenn der Quellcode nicht
mehr zur Verfügung steht, als besonders nützlich.
Um Java-Binärdateien zu importieren, müssen Java Runtime Environment (JRE) oder Development
Kit (JDK) Version 1.4, 1.5, 1.6, 1.7, 1.8 installiert sein. Der Import von Typen wird für Class
Archives unterstützt, die für diese Umgebungen vorgesehen sind, d.h. die den Java Virtual
Machine Spezifikationen entsprechen.
Um C#- oder VB-Binärdateien zu importieren, muss das .NET Framework installiert sein. Der
Import von Typen wird für Assemblies unterstützt, die für folgende Umgebungen vorgesehen
sind: .NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.6 sowie .NET Compact Framework v1.0, v2.0,
v3.5 (für PocketPC, Smartphone, WindowsCE).
Diese Anforderungen gelten nur für den Import von Java-, C#- oder VB.NET-Binärdateien.
Andernfalls wird die Java Runtime-Umgebung oder das .NET Framework nicht benötigt.
Der Import von Binärdateien, die mit Hilfe eines Obfuscators unleserlich gemacht wurden, wird
nicht unterstützt.
So importieren Sie Binärdateien:
1. Wählen Sie die Menüoption Projekt | Binärtypen importieren.
© 2016 Altova GmbH
Altova UModel 2017
132
2. Wählen Sie die Sprache und die Runtime Version aus.
3. Damit UModel Klassen- und Paketdiagramme anhand des Quellcodes generiert,
aktivieren Sie das Kontrollkästchen "Diagrammgenerierung aktivieren".
4. Klicken Sie auf "Weiter". Daraufhin wird das Dialogfeld "Ausgewählte Binärtypen
importieren" geöffnet.
5. Klicken Sie auf Hinzufügen und wählen in im Kontextmenü das Class Archive aus (in
diesem Beispiel Class Archives von Java Runtime).
6. Wählen Sie eine Binärdatei aus (in diesem Beispiel rt.jar).
4. Klicken Sie auf das "+" Erweiterungssymbol, um die Liste der Binärdateien zu erweitern
und aktivieren Sie das/die Kontrollkästchen jener Datei(en), die Sie importieren möchten.
Altova UModel 2017
© 2016 Altova GmbH
133
8. Klicken Sie auf "Weiter". Daraufhin wird das Dialogfeld Optionen für den Import von
Binärdateien.
© 2016 Altova GmbH
Altova UModel 2017
134
9. Klicken Sie auf "Weiter".
10. Wählen Sie, wenn Sie dazu aufgefordert werden, das Importziel aus oder aktivieren Sie
das Kontrollkästchen In neues Paket importieren und klicken Sie zum Fortfahren auf
"Weiter".
Altova UModel 2017
© 2016 Altova GmbH
135
11. Wählen Sie im Dialogfeld die Eigenschaften für die Generierung eines Inhaltsdiagramms
aus und klicken Sie zum Fortfahren auf "Weiter".
Sie können für jedes Paket ein Diagramm generieren, haben aber auch die Möglichkeit,
ein Übersichtsdiagramm zu erzeugen.
© 2016 Altova GmbH
Altova UModel 2017
136
12. Wählen Sie die gewünschten Paketabhängigkeitsoptionen aus und klicken Sie auf "Fertig
stellen", um den Importvorgang fertig zu stellen. In der Abbildung unten sehen Sie das
Diagramm, das die Paketabhängigkeiten der Java-Binärdateien enthält.
Anmerkung: Wenn Sie auf das Link-Symbol eines Ordners klicken, wird das referenzierte
Diagramm automatisch geöffnet.
Altova UModel 2017
© 2016 Altova GmbH
6.4
Synchronisieren von Modell und Quellcode
137
Sie können Modell und Code in beiden Richtungen und auf unterschiedlichen Ebenen (z.B.
Projekt, Paket oder Klasse) synchronisieren.
Wenn UModel (Enterprise oder Professional) als Eclipse- oder Visual Studio Plug-in
ausgeführt wird, erfolgt die Synchronisierung zwischen Modell und Code
automatisch. Eine manuelle Synchronisierung ist auf Projektebene möglich; die
Option zum Aktualisieren einzelner Klassen oder Pakete steht nicht zur Verfügung.
Bei Rechtsklick auf ein Element in der Modellstruktur (z.B. eine Klasse) werden im Kontextmenü
unter dem Eintrag Code Engineering die Befehle zur Synchronisierung oder zum
Zusammenführen von Code angezeigt:
Merge Programmcode von UModel Projekt ***
Merge UModel Projekt von Programmcode ***
*** ist je nach aktueller Auswahl ein Projekt, Paket, eine Komponente oder eine
Klasse usw.
Je nachdem, welche Einstellungen Sie unter Projekt | Synchronisierungseinstellungen
definiert haben, können die Namen dieser beiden Befehle auch folgendermaßen lauten:
Überschreibe Programmcode von UModel Projekt ***
Überschreibe UModel Projekt von Programmcode ***
Um das gesamte Projekt (nicht aber Klassen, Pakete oder andere lokale Elemente) zu
aktualisieren, können Sie auch die beiden folgenden Befehle aus dem Projekt-Menü von UModel
verwenden:
Merge (oder Überschreibe) Programmcode aus UModel Projekt
Merge (oder Überschreibe) UModel Projekt aus Programmcode
Aus Gründen der Einfachheit werden die oben aufgelisteten Befehle in diesem Kapitel allgemein
als Codesynchronisierungsbefehle bezeichnet.
Wählen Sie eine der folgenden Methoden, um eine Synchronisierung auf Projekt- oder
Root-Paketebene durchzuführen:
Klicken Sie mit der rechten Maustaste auf das Root-Paket in der Modell-Struktur und
wählen Sie den gewünschten Codesynchronisierungsbefehl aus.
Klicken Sie im Menü Projekt auf den gewünschten Codesynchronisierungsbefehl.
So führen Sie eine Synchronisierung auf Paketebene durch:
1. Drücken Sie Umschalt + Klick oder Strg + Klick, um das/die gewünschte(n) Paket(e)
auszuwählen
2. Klicken Sie mit der rechten Maustaste auf die Auswahl und wählen Sie den gewünschten
© 2016 Altova GmbH
Altova UModel 2017
138
Codesynchronisierungsbefehl aus.
So führen Sie eine Synchronisierung auf Klassenebene durch:
1. Drücken Sie Umschalt + Klick oder Strg + Klick, um die gewünschte(n) Klasse(n)
auszuwählen
2. Klicken Sie mit der rechten Maustaste auf die Auswahl und wählen Sie den gewünschten
Codesynchronisierungsbefehl aus.
Um beim Synchronisieren von Modell und Code unerwünschte Ergebnisse zu vermeiden,
betrachten Sie bitte die folgenden Szenarien:
Auswahl des Befehls Überschreibe
UModel Projekt aus
Programmcode im Menü Projekt
Dabei werden alle Verzeichnisse (Projektdateien)
aller verschiedenen von Ihnen in Ihrem Projekt
definierten Codesprachen überprüft.
Neue Dateien werden ermittelt und zum Projekt
hinzugefügt.
In Ihrem Meldungsfenster erscheint der Eintrag
"Quelldateien werden in 'C:\UMTest' gesammelt".
Rechtsklick auf eine Klasse oder
Schnittstelle in der Modell-Struktur und
Auswahl von Code Engineering |
Überschreibe UModel Klasse von
Programmcode
Daraufhin wird nur die ausgewählte Klasse
(Schnittstelle,...) Ihres Projekts aktualisiert.
Wenn der Quellcode jedoch neue oder seit der
letzten Synchronisierung geänderte Klassen
enthält, werden diese Änderungen nicht zum Modell
hinzugefügt.
Rechtsklick auf eine Komponente in
der Modell-Struktur (im Component
View-Paket) und Auswahl von Code
Engineering | Überschreibe UModel
Komponente von Programmcode
Daraufhin wird nur das entsprechende Verzeichnis
(bzw. die entsprechende Projektdatei) aktualisiert.
Neue Dateien im Verzeichnis (in der Projektdatei)
werden ermittelt und zum Projekt hinzugefügt.
In Ihrem Meldungsfenster erscheint der Eintrag
"Quelldateien werden in 'C:\UMTest' gesammelt".
Anmerkung:
Unter Umständen wird beim Synchronisieren von Code ein Dialogfeld angezeigt, in dem
Sie aufgefordert werden, Ihr UModel-Projekt vor dem Synchronisieren zu aktualisieren.
Dies kommt nur bei UModel-Projekten vor, die mit einer Vorversion der letzten Release
erstellt wurden. Klicken Sie bitte auf JA um Ihr Projekt zu aktualisieren und Ihre
Projektdatei zu speichern. Anschließend wird diese Aufforderung nicht mehr angezeigt.
Synchronisierungseinstellungen
Sie können die Synchronisierungsoptionen über den Menübefehl Projekt |
Synchronisierungsoptionen ändern.
Altova UModel 2017
© 2016 Altova GmbH
139
SPL-Vorlagen
SPL-Vorlagen werden bei der Generierung von Java-, C#- und VB.NET-Code verwendet. SPLVorlagen werden nur verwendet/aufgerufen, wenn neuer Code generiert wird, d.h. wenn neuer
Code generiert wird, d.h. wenn Klassen, Operationen usw. zum Modell hinzugefügt wurden.
Bestehender Code ruft die SPL-Vorlagen nicht auf bzw. greift nicht darauf zu.
So ändern Sie die vorgegebenen SPL-Vorlagen:
1. Suchen Sie die vordefinierten SPL-Vorlagen im UModel-Installationsverzeichnis:
("Programme" ...\UModel2017\UModelSPL\Java\Default\. (oder ...\C#\Default, ...\VB
\Default.)
2. Kopieren Sie die SPL-Dateien, die Sie ändern möchten, in das übergeordnete
Verzeichnis, d.h. in ...\UModel2017\UModelSPL\Java\.
3. Nehmen Sie die gewünschten Änderungen vor und speichern Sie sie.
So verwenden Sie die benutzerdefinierten SPL-Vorlagen:
1. Wählen Sie die Menüoption Projekt | Synchronisierungseinstellungen.
2. Aktivieren Sie das Kontrollkästchen "Benutzerdefinierte setzt Standardvorlage außer
Kraft" in der Gruppe "SPL-Vorlagen".
© 2016 Altova GmbH
Altova UModel 2017
140
6.4.1
Tipps zur Synchronisierung
Umbenennen von Classifiern und Reverse Engineering
Der unten beschriebenen Vorgang beim Reverse Engineering oder der automatischen
Synchronisierung bezieht sich sowohl auf die Standalone-Applikation als auch auf die Plug-InVersionen (Visual Studio oder Eclipse).
Wenn Sie einen Classifier im Code-Fenster Ihrer Programmierapplikation umbenennen, wird er
gelöscht und als neuer Classifier in die Modell-Struktur eingefügt.
Der neue Classifier wird nur in diejenigen Modellierungsdiagramme eingefügt, die beim Reverse
Engineering automatisch erstellt werden, oder wenn ein Diagramm mit dem Befehl In neuem
Diagramm anzeigen | Inhalt erstellt wird. Der neue Classifier wird an der Standardposition im
Diagramm eingefügt. Diese ist wahrscheinlich nicht mit der vorherigen Position identisch.
Siehe auch Refactoring und Synchronisierung von Code.
Automatische Generierung von Komponentenrealisierungen
UModel kann in Rahmen der Codegenerierung automatisch Komponentenrealisierungen
generieren. Komponentenrealisierungen werden nur generiert, wenn es absolut klar ist, welcher
Komponente eine Klasse zugewiesen werden soll:
Es ist nur eine Visual Studio-Projektdatei im .ump-Projekt vorhanden.
Es gibt mehrere Visual Studio-Projekte, doch deren Klassen sind im Modell streng
getrennt.
So aktivieren Sie die automatische Generierung von Komponentenrealisierungen:
1. Wählen Sie den Menübefehl Extras | Optionen.
2. Klicken Sie auf das Register Code Engineering und aktivieren Sie die Option Fehlende
Komponentenrealisierungen generieren.
Automatische Komponentenrealisierungen werden für einen Classifier generiert, dem eine (und
nur eine) Komponente zugewiesen werden kann.
ohne Komponentenrealisierung oder
eine im Namespace einer Codesprache enthaltene Komponente
Die Art, wie die Komponente gesucht wird, ist in den beiden Fällen unterschiedlich:
Komponente, die eine Code-Projektdatei repräsentiert (Eigenschaft "projectfile" ist aktiviert)
wenn es EINE Komponente gibt, die Classifier im Paket, das sie enthält, hat/realisiert
wenn es EINE Komponente gibt, die Classifier in einem Unterpaket, des Pakets, das sie
enthält, hat/realisiert (von oben nach unten)
wenn es EINE Komponente gibt, die Classifier in einem der übergeordneten Pakete hat/
realisiert (von unten nach oben)
wenn es EINE Komponente gibt, die Classifier in einem Unterpaket eines der
übergeordneten Paket hat/realisiert (von oben nach unten)
Altova UModel 2017
© 2016 Altova GmbH
141
Komponente, die ein Verzeichnis repräsentiert (Eigenschaft "directory" ist aktiviert)
wenn es EINE Komponente gibt, die Classifier im Paket, das sie enthält, hat/realisiert
wenn es EINE Komponente gibt, die Classifier in einem der übergeordneten Pakete hat/
realisiert (von unten nach oben)
Anmerkungen:
Die Option "Code Engineering | Fehlende Komponentenrealisierungen
generierten" muss aktiviert sein.
Sobald bei einem der obigen Schritte EINE verwendbare Komponente gefunden wird, wird
diese Komponente verwendet und die restlichen Schritte werden ignoriert!
Fehler/Warnungen:
Wenn keine verwendbare Komponente gefunden wird, wird eine Warnmeldung generiert
(Meldungsprotokoll)
Wenn mehrere verwendbare Komponenten gefunden werden, wird eine Fehlermeldung
generiert (Meldungsprotokoll)
© 2016 Altova GmbH
Altova UModel 2017
142
6.4.2
Refactoring und Synchronisierung von Code
Beim Refactoring von Code müssen oft Klassennamen geändert/aktualisiert werden. In Versionen
vor UModel 2009 wurden bei der Synchronisierung von Code die "alten" Klassen gelöscht und
neue eingefügt.
Falls in UModel ab Version 2009 beim Reverse Engineering festgestellt wird, dass neue Typen
hinzugekommen/umbenannt worden sind, wird nun ein Dialogfeld geöffnet. Die neuen Typen
werden in der Spalte "Name im Code" geöffnet, während der vom Programm als ursprünglicher
Typname angenommene Name in der Spalte "Name im Modell" aufgelistet wird. UModel ermittelt
den Originalnamen anhand vonn Namespace, Klasseninhalt, Basisklassen und anderen Daten.
Wenn eine Klasse umbenannt wurde, wählen Sie den früheren Klassennamen über die
Auswahlliste in der Spalte "Name im Modell" aus, z.B. C1. Damit stellen Sie sicher, dass alle
damit in Zusammenhang stehenden Daten beibehalten werden und das Code Engineering korrekt
erfolgt.
Ändern von Klassennamen im Modell und Neugenerierung von Code
Wenn Sie ein Modell erstellt haben und anhand dieses Modells Code generiert haben, möchten
Sie unter Umständen nochmals Änderungen am Modell vornehmen, bevor Sie die
Synchronisierung vornehmen.
Beispiel: Sie haben beschlossen, Klassennamen zu ändern, bevor Sie Code zum zweiten Mal
generieren. Da Sie jeder Klasse zuvor einen Dateinamen zugewiesen haben, würde der neue
Name der Klasse und der Datei nun im Fenster "Eigenschaften" im Feld "Codedateiname" nicht
mehr übereinstimmen.
UModel fragt Sie, ob der Name der Codedatei an den neuen Namen der Klasse angepasst werden
soll, bevor Sie die Synchronisierung starten. Beachten Sie, dass Sie auch die Möglichkeit haben,
auch die Klassenkonstruktoren zu ändern.
Altova UModel 2017
© 2016 Altova GmbH
143
Round-Trip Engineering und Beziehungen zwischen Modellelementen:
Beim Aktualisieren des Modells anhand von Code werden Assoziationen zwischen
Modellelementen automatisch angezeigt, wenn die Option Bearbeiten | Assoziationen
automatisch erstellen im Dialogfeld Extras | Optionen aktiviert wurde. Assoziationen werden für
jene Elemente angezeigt, bei denen der Attributtyp definiert ist und bei denen sich das
referenzierte "Typ"-Modellelement im selben Diagramm befindet.
Die Schnittstellenrealisierungen sowie die Generalisierungen werden beim Aktualisieren des
Modells anhand von Code automatisch angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
144
Voraussetzungen für Forward Engineering
6.5
Mindestvoraussetzungen für das Erzeugen von Code für das Forward Engineering:
Eine Komponente muss durch eine oder mehrere Klassen oder Schnittstellen
realisiert werden.
Die Komponente muss einen physischen Pfad haben, d.h. es muss ihr ein Verzeichnis
zugewiesen sein. Der generierte Code wird anschließend in diesem Verzeichnis
abgelegt.
Komponenten müssen einzeln in den Code Engineering-Vorgang inkludiert werden.
Das Java-, C#- oder VB-Namespace-Root-Paket muss definiert werden.
So erstellen Sie eine Komponentenrealisierung:
1. Ziehen Sie die Klasse bzw. Schnittstelle auf die jeweilige Komponente in der ModellStrukturansicht.
Sie können auch über das Symbol "Realisierung" in einem Komponentendiagramm eine
Realisierung erstellen.
So weisen Sie einen physischen Ordner zu:
1. Wählen Sie die Komponente in der Modell-Struktur oder im Diagramm aus.
der Eigenschaft Verzeichnis und
wählen Sie ein Verzeichnis aus (oder geben Sie es direkt ein).
So inkludieren Sie Komponenten in den Code Engineering-Vorgang:
1. Wählen Sie die Komponente in der Modell-Struktur oder im Diagramm aus.
Altova UModel 2017
© 2016 Altova GmbH
145
2. Aktivieren Sie das Kontrollkästchen "use for code engineering".
So definieren Sie die Java Namespace Root:
1. Durch Rechtsklick auf ein Paket und Auswahl der Option "Als Java Namespace Root
definieren" wird die Java Namespace Root definiert.
Diese bedeutet, dass dieses Paket und alle Unterpakete während des Code EngineeringVorgangs aktiviert sind. Die Java Namespace Root im Modell-Strukturbereich ist durch
ein
Symbol gekennzeichnet.
Wenn Sie den Befehl nochmals auswählen, wird der Java Namespace aus diesem Paket
entfernt.
© 2016 Altova GmbH
Altova UModel 2017
146
Generieren von Java-Code aus UModel-Elementen und umgekehrt
6.6
Generieren von Java-Code aus UModel-Elementen und
umgekehrt
In der nachstehenden Tabelle sehen Sie die Eins-zu-Eins-Entsprechungen zwischen:
UModel-Elementen und Java-Code-Elementen bei Ausgabe eines Modells in Code
Java-Code-Elementen und UModel-Modellelementen bei Eingabe von Code aus dem
Modell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER um die
HTML-Version der Tabelle in Ihrem Browser zu öffnen.
Altova UModel 2017
© 2016 Altova GmbH
6.7
Generieren von C#-Code aus UModel Elementen und umgekehrt
147
Generieren von C#-Code aus UModel Elementen und
umgekehrt
In der nachstehenden Tabelle sehen Sie die Eins-zu-Eins-Entsprechungen zwischen:
UModel-Elementen und C#-Code-Elementen bei Ausgabe eines Modells in Code
C#-Code-Elementen und UModel -Modellelementen bei Eingabe von Code in das Modell
© 2016 Altova GmbH
Altova UModel 2017
148
XML Schema von/zu UModel Elementen
6.8
XML Schema von/zu UModel Elementen
In der unten stehenden Tabelle sehen Sie die Eins-zu-Eins-Entsprechungen zwischen:
UModel Elementen und XML-Schema-Elementen bei der Ausgabe des Modells in Code
XML-Schema-Elemente und UModel Modellelemente, bei der Eingabe von Code ins
Modell
Altova UModel 2017
© 2016 Altova GmbH
6.9
Konvertierung VB.NET-Code - UModel-Elemente
149
Konvertierung VB.NET-Code - UModel-Elemente
In der unten stehenden Tabelle sehen Sie die 1:1-Entsprechungen zwischen:
UModel -Elementen und VB.NET-Codeelementen bei der Ausgabe von Modell in Code
VB.NET-Code-Elementen und UModel-Modellelementen bei der Eingabe von Code in das
Modell
© 2016 Altova GmbH
Altova UModel 2017
150
Konvertierung Datenbanken - UModel-Elemente
6.10 Konvertierung Datenbanken - UModel-Elemente
In der unten stehenden Tabelle sehen Sie die 1:1-Entsprechungen zwischen:
UModel -Elementen und Datenbankelementen bei der Ausgabe von Modell in Code
Datenbankelementen und UModel-Modellelementen bei der Eingabe von Code in das
Modell
Altova UModel 2017
© 2016 Altova GmbH
Inkludieren anderer UModel-Projekte
151
6.11 Inkludieren anderer UModel-Projekte
Um ein UModel-Projekt als Unterprojekt eines anderen UModel-Projekts zu inkludieren, wählen
Sie den Menbefehl Projekt | Unterprojekt inkludieren.
Dialogfeld "Unterproj ekt inkludieren"
Die Register und UModel-Projekte im Dialogfeld "Unterprojekt inkludieren" sind konfigurierbar.
UModel liest diese Informationen aus dem folgenden Pfad (relativ zum Ordner "Programme" Ihres
Betriebssystems): \Altova\UModel2017\UModelInclude. Beachten Sie, dass sich die
Projektdateien auf dem Register Basic direkt unterhalb des Ordners UModelInclude befinden,
während sich die Projekte auf den verschiedenen Java-, VB- und C#-Registern in Unterordnern des
Ordners UModelInclude befinden.
Standardmäßig bietet UModel mehrere Projektprofile (.ump-Dateien) für Ihr UModel Projekt. So
befinden sich etwas Java Lang-Klassen, -Schnittstellen und -Pakete auf den nach Java-Version
geordneten Java-Registern. Auf die gleiche Weise stehen auch die .ump-Dateien für die Microsoft
C#- und VB-Typen auf separaten nach Version geordneten Registern zur Verfügung.
So zeigen Sie alle derzeit importierten Projekte an:
Wählen Sie die Menüoption Projekt | Unterprojekt separat öffnen.
Das Menü, das erscheint, enthält die aktuell inkludierten Unterprojekte.
© 2016 Altova GmbH
Altova UModel 2017
152
Inkludieren anderer UModel-Projekte
So erstellen Sie im Dialogfeld "Unterprojekt inkludieren" ein benutzerdefiniertes
Register:
Navigieren Sie zum Ordner \Altova\UModel2017\UModelInclude (relativ zu Ihrem
Ordner "Programme") und erstellen Sie Ihren benutzerdefinierten Ordner unterhalb, z.B.
\UModelInclude\myfolder. Als Name des Registers im Dialogfeld "Unterrprojekt
inkludieren" wird der Name, den Sie dem Ordner geben, angezeigt.
Kopieren Sie alle .ump-Dateien, die Sie auf dem entsprechenden Register zur Verfügung
stellen möchten, in Ihren benutzerdefinierten Ordner.
So erstellen Sie beschreibenden Text zu jeder UModel Projektdatei:
Erstellen Sie eine Textdatei mit demselben Namen wie die *.ump-Datei und platzieren Sie
sie in denselben Ordner. So wird z.B. für die Datei MyModel.ump eine beschreibende
Datei names MyModel.txt benötigt. Stellen Sie bitte sicher, dass die Codierung dieser
Textdatei UTF-8 ist.
So entfernen Sie ein inkludiertes Projekt:
1. Klicken Sie in der Modell-Strukturansicht auf das inkludierte Paket und drücken Sie die
Entf-Taste.
2. Sie werden gefragt, ob Sie mit dem Löschen fortfahren wollen.
3. Klicken Sie auf OK, um die inkludierte Datei aus dem Projekt zu löschen.
So löschen oder entfernen Sie ein Projekt aus dem Dialogfeld "Unterprojekt
inkludieren":
Löschen oder entfernen Sie die .ump-Datei (MyModel.ump) aus dem entsprechenden
Ordner.
Altova UModel 2017
© 2016 Altova GmbH
Zusammenführen von UModel-Projekten
153
6.12 Zusammenführen von UModel-Projekten
UModel unterstützt nun 2-Weg- und 3-Weg-Projektzusammenführungen. In beiden Fällen werden
unterschiedliche UModel-Projektdateien zu einem gemeinsamen UModel *.ump Modell
zusammengeführt.
Dies ist hilfreich, wenn mehrere Personen gleichzeitig am selben Projekt arbeiten oder wenn Sie
Ihre Arbeit einfach in einem einzigen Modell zusammenführen möchten.
Nähere Informationen dazu finden Sie unter:
© 2016 Altova GmbH
Altova UModel 2017
154
So führen Sie zwei UML-Projekte zusammen:
1. Öffnen Sie die UML-Datei, in die das zweite Modell überführt werden soll.
2. Wählen Sie die Menüoption Projekt | Projekt zusammenführen....
3. Wählen Sie das zweite UML-Projekt aus, also das Projekt, das in die erste Datei
überführt werden soll.
Im Meldungsfenster sehen Sie Meldungen über den Ablauf der Zusammenführung und die
relevanten Einzelheiten werden protokolliert.
Bitte beachten Sie:
Wenn Sie auf einen der Einträge im Meldungsfenster klicken, wird das entsprechende
Modellierungselement in der Modell-Struktur angezeigt.
Ergebnisse der Zusammenführung:
Neue Modellierungselemente, d.h. Elemente, die in der Quelle nicht vorhanden sind,
werden zum Projekt hinzugefügt.
Unterschiede in denselben Modellierungselementen; die Elemente aus dem zweiten
Modell haben Vorrang. So kann es z.B. nur einen Standardwert für ein Attribut geben. Es
wird der Standardwert aus der zweiten Datei verwendet.
Diagrammunterschiede: UModel überprüft zuerst, ob es Unterschiede zwischen den
Diagrammen der beiden Modelle gibt.
Wenn ja, so wird das neue/unterschiedliche Diagramm zum Modell hinzugefügt (und eine
fortlaufende Nummerierung wird an den Namen des Diagramms angehängt, z.B: activity1
usw.) und das ursprüngliche Diagramm wird beibehalten.
Falls keine Unterschiede vorhanden sind, werden identische Diagramme ignoriert und es
werden keine Änderungen vorgenommen.
Sie können anschließend entscheiden, welches der Diagramme Sie beibehalten oder
löschen möchten. Natürlich können Sie auch beide Diagramme beibehalten, wenn Sie
möchten.
Die gesamte Zusammenführung kann Schritt für Schritt rückgängig gemacht werden.
Klicken Sie dazu in der Symbolleiste auf das Symbol "Rückgängig" oder drücken Sie
Strg + Z.
Wenn Sie im Meldungsfenster auf einen Eintrag klicken, wird das entsprechende Element
in der Modell-Struktur angezeigt.
Der Dateiname der zusammengeführten Datei, also der ersten Datei, die Sie geöffnet
haben, wird beibehalten!
Altova UModel 2017
© 2016 Altova GmbH
155
UModel unterstützt nun die Zusammenführung mehrerer UModel-Projekte, die gleichzeitig von
mehreren Entwicklern bearbeitet wurden, in einer 3-Weg-Projektzusammenführung.
Projektzusammenführung
Die 3-Weg-Projektzusammenführung funktioniert bei UModel-Projekten der obersten Ebene, d.h.
Projekten die auch Unterprojekte enthalten können. Nicht unterstützt wird die Zusammenführung
einzelner Dateien, wenn diese Dateien nicht aufgelöste Referenzen auf andere Dateien enthalten.
Bei der Zusammenführung von Hauptprojekten werden auch alle editierbaren Unterprojekte
automatisch zusammengeführt. Die Unterprojekte müssen nicht separat zusammengeführt
werden.
Ein einfaches Beispiel finden Sie unter Beispiel einer manuellen 3-Weg-Projektzusammenführung.
Die gesamte Projektzusammenführung kann durch Klicken auf die "Rückgängig"Schaltfläche in der Symbolleiste oder Drücken von Strg+Z Schritt für Schritt rückgängig
gemacht werden.
Wenn Sie im Fenster "Meldungen" auf einen Eintrag klicken, wird dieses Element in der
Modell-Struktur angezeigt.
Der Dateiname der zusammengeführten Datei, also der ersten Datei, die Sie geöffnet
haben, wird beibehalten.
Ergebnisse der Zusammenführung:
Anmerkung: Mit Quelle wird im Folgenden die Anfangsprojektdatei bezeichnet, also die Datei, die
Sie geöffnet haben, bevor Sie mit der Zusammenführung begonnen haben.
Neue Modellierungselemente in der zweiten Datei, also Elemente, die in der Quelle nicht
vorhanden sind, werden zum zusammengeführten Modell hinzugefügt.
Neue Modellierungselemente in der Quelldatei, also Elemente, die in der zweiten Datei
nicht vorhanden sind, bleiben im zusammengeführten Modell erhalten.
Gelöschte Modellierungselemente aus der zweiten Datei, also Elemente, die in der
Quelle noch immer vorhanden sind, werden aus dem zusammengeführten Modell entfernt.
Gelöschte Modellierungselemente aus der Quelldatei, also Elemente, die in der zweiten
Datei noch vorhanden sind, bleiben im zusammengeführten Modell gelöscht.
Unterschiede im selben Modellierungselement:
Wenn eine Eigenschaft (z.B. die Sichtbarkeit einer Klasse) in der Quelldatei oder der
zweiten Datei geändert wurde, so wird im zusammengeführten Modell der aktualisierte
Wert verwendet
Wenn eine Eigenschaft (z.B. die Sichtbarkeit einer Klasse) sowohl in der Quelle als
auch in der zweiten Datei geändert wurde, so wird der Wert aus der zweiten Datei
verwendet (und im Meldungsfenster unterhalb wird eine Warnmeldung angezeigt)
Verschobene Elemente:
Wenn ein Element in der Quelle oder der zweiten Datei verschoben wurde, so wird das
Element im zusammengeführten Modell ebenfalls verschoben
Wenn ein Element sowohl in der Quelle als auch in der zweiten Datei (in
© 2016 Altova GmbH
Altova UModel 2017
156
unterschiedliche Parent-Elemente) verschoben wird, so erscheint eine Meldung, in der
Sie aufgefordert werden, das Parent-Element im zusammengeführten Modell manuell
auszuwählen.
Diagrammunterschiede:
UModel überprüft zuerst, ob zwischen den Diagrammen der beiden Modelle Unterschiede
bestehen.
Falls dies der Fall ist, so wird das neue/geänderte Diagramm zum zusammengeführten
Modell (mit einer fortlaufenden Nummer, wie activity1 usw.) hinzugefügt und das Original
wird beibehalten.
Wenn es keine Unterschiede gibt, so werden identische Diagramme ignoriert, d.h. es gibt
keine Änderungen.
Sie können später entscheiden, welches der Diagramme beibehalten oder gelöscht
werden soll. Natürlich können Sie auch beide Diagramme beibehalten.
Versionskontrollunterstützung für 3-Weg-Zusammenführungen
Beim Ein-/Auschecken von Projektdateien generiert UModel automatisch "gemeinsame
Vorgängerdateien" (oder Schnappschussdateien), anhand derer anschließend die 3-WegProjektzusammenführung durchgeführt wird. Dies ermöglicht viel genauere
Zusammenführungsresultate als die normale 2-Weg-Zusammenführung.
Es hängt vom jeweiligen Versionskontrollsystem, das Sie verwenden, ab, ob UModel die
automatische 3-Weg-Zusammenführung über die Schnappschussdatei unterstützt. Eine manuelle
3-Weg-Zusammenführung ist jedoch immer möglich.
Versionskontrollsysteme, die die Dateizusammenführung durchführen, ohne dass der
Benutzer darauf Einfluss nehmen kann, werden eine automatische 3-WegZusammenführung wahrscheinlich nicht unterstützen.
Versionskontrollsysteme, in denen Sie bei einem geänderten Projekt zwischen Ersetzen
und Zusammenführen wählen können, unterstützen eine 3-Weg-Zusammenführung im
Allgemeinen. Nachdem das Versionskontroll-Plugin die Datei ersetzt hat, wird bei
Auswahl des Befehls "Ersetzen" eine UModel-Dateiwarnung aktiviert, die Ihnen dann
gestattet, eine 3-Weg-Zusammenführung durchzuführen. Das Ein- und Auschecken muss
über UModel erfolgen.
Haupt- und Unterprojekte können unter Versionskontrolle gestellt werden. Wenn Daten in
einem Unterprojekt geändert wurden, werden Sie automatisch gefragt, ob das/die
Unterprojekte ausgecheckt werden sollen.
Bei jedem Ein-/Auscheckvorgang wird eine gemeinsame Vorgänger- oder
Schnappschussdatei erstellt, die dann für die 3-Weg-Projektzusammenführung verwendet
wird.
Bitte beachten Sie:
Schnappschussdateien werden nur mit den Standalone-Versionen von UModel
automatisch erstellt und verwendet, d.h. diese Funktionen stehen in der Eclipse- und der
Visual Studio-Plugin-Version nicht zur Verfügung.
Beispiel
Benutzer A bearbeitet eine UModel-Projektdatei und ändert den Namen einer Klasse im
BankView-Hauptdiagramm. Benutzer B öffnet dieselbe Projektdatei und ändert die Sichtbarkeit
Altova UModel 2017
© 2016 Altova GmbH
157
derselben Klasse.
Anhand der Schnappschussdateien, die für die einzelnen Benutzer erstellt wurden, wird ein
Bearbeitungsverlauf erstellt, der eine Zusammenführung der einzelnen Änderungen im Projekt
ermöglicht. Sowohl die Änderungen am Namen als auch an der Sichtbarkeit werden bei der 3Weg-Zusammenführung in der Projektdatei zusammengeführt.
© 2016 Altova GmbH
Altova UModel 2017
158
6.12.3 Beispiel: Manuelle 3-Weg-Projektzusammenführung
In diesem einfachen Beispiel wird die Datei Bank_CSharp.ump aus dem Ordner ...
\UModelExamples verwendet. Zwei weitere Instanzen desselben Projekts werden in
untergeordnete Verzeichnisse unterhalb des Verzeichnisses UModelExamples kopiert, also.
\C#_1 und \C#_2.
User1 öffnet die Projektdatei Bank_CSharp.ump im Ordner C#_1 und nimmt die Änderungen an
der BankView Klasse vor.
Änderungen an der BankView-Klasse:
1. Die Operation CollectAccountInfos():bool wird aus der BankView-Klasse gelöscht.
2. Die Sichtbarkeit (visibility) der Operation CollectBankAddressInfos():bool wird von
"protected" in "public" geändert.
3. Anschließend wird das Projekt gespeichert.
User2 öffnet die Projektdatei Bank_CSharp.ump im Ordner C#_2 und nimmt Änderungen an der
Bank-Klasse vor.
Altova UModel 2017
© 2016 Altova GmbH
159
Änderungen an der Bank-Klasse:
1. Die Operationen CollectAccountInfos... und GetBalanceOfAccounts... werden beiden
von "public" in "protected" geändert.
2. Anschließend wird das Projekt gespeichert.
User2 startet nun eine 3-Weg-Projektzusammenführung:
1. Wählen Sie Projekt | Projekt zusammenführen (3-Weg).
Daraufhin wird das Dialogfeld "Datei öffnen" angezeigt.
2. Wählen Sie die von User1 geänderte Projektdatei im Ordner ...\C#_1 aus.
© 2016 Altova GmbH
Altova UModel 2017
160
Sie werden nun aufgefordert, die gemeinsame Vorgängerdatei zu öffnen. Dabei handelt
es sich um die Originalprojektdatei im Ordner ...\UModelExamples.
Die 3-Weg-Zusammenführung wird gestartet und sie kehren zur Projektdatei, von der aus
Sie die 3-Weg-Zusammenführung gestartet haben, also zur Projektdatei im Ordner C#_2,
zurück.
Im Fenster "Meldungen" wird die Zusammenführung im Detail angezeigt.
Die am Projekt im Ordner C#_1 vorgenommenen Änderungen werden in der Projektdatei
C#_2 repliziert.
Die am Projekt im Ordner C#_2 vorgenommenen Änderungen werden in der Projektdatei
beibehalten.
Bei 3-Weg-Zusammenführungen zwischen den Projektdateien in den Ordnern C#_1 und
C#_2 sollte nun in Zukunft die Projektdatei im Ordner C#_2 sollte als gemeinsame
Vorgängerdatei verwendet werden.
Altova UModel 2017
© 2016 Altova GmbH
Freigeben von Paketen und Diagrammen
161
6.13 Freigeben von Paketen und Diagrammen
UModel gestattet Ihnen, Pakete und eventuell darin enthaltene UML-Diagramme freizugeben und
in mehreren Projekten zu verwenden. Pakete können mittels Referenz oder in Form einer Kopie in
andere UModel-Projekte inkludiert werden.
Beachten Sie bitte außerdem, dass Unterprojektdateien jederzeit von einem Haupt- oder
Unterprojekt abgeteilt werden können. Die Unterprojektdateien können vom Hauptprojekt aus als
editierbare oder als schreibgeschützte Projekte inkludiert werden; die einzelnen Pakete werden
freigegeben und als Unterprojektdatei gespeichert und können zu einem Versionskontrollsystem
hinzugefügt werden. Nähere Informationen dazu finden Sie unter Unterstützung für die Arbeit im
Team an UModel-Projekten.
Voraussetzungen für freigegebene Pakete:
Objektbeziehungen zu anderen Paketen außerhalb des freigegebenen Bereichs sind nicht
zulässig.
Anmerkung:
Wenn Sie UModel-Projektdateien erstellen, verwenden Sie nicht eine einzige Projektdatei
als "Vorlage/Kopie" für eine andere Projektdatei, in der Sie ein Paket freigeben möchten.
Dies kann zu Konflikten führen, da jedes Element global nur einmal vorhanden sein sollte
(siehe uuid). Dies wäre dann nicht der Fall, da zwei Projekte dann Elemente mit
identischen uuids hätten.
So verwenden Sie ein Paket in mehreren Projekten:
1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf ein Paket und wählen Sie
Unterprojekt | Paket freigeben.
In der Modell-Struktur wird unterhalb des freigegebenen Pakets ein "freigegeben"-Symbol
angezeigt. Dieses Paket kann nun in jedes beliebige andere UModel-Projekt inkludiert
werden.
So inkludieren/importieren Sie einen freigegebenen Ordner in ein Projekt:
1. Öffnen Sie das Projekt, das das freigegebene Paket enthalten soll (in diesem Beispiel ein
leeres Projekt).
2. Wählen Sie den Menüeintrag Projekt | Unterprojekt inkludieren...
3. Klicken Sie auf die Durchsuchen-Schaltfläche, wählen Sie das Projekt, das das
freigegebene Paket enthält, aus und klicken Sie auf "Öffnen".
© 2016 Altova GmbH
Altova UModel 2017
162
Im Dialogfeld "Inkludieren" können Sie das Paket/Projekt in Form einer Referenz oder als
Kopie inkludieren.
4. Wählen Sie die gewünschte Option ("Durch Referenz") und klicken Sie auf OK.
Im neuen Paket ist nun das Paket "Deployment View" zu sehen. Das Quellprojekt des
Pakets wird in Klammern angezeigt (BankView-start.ump).
Freigegebene Ordner, die in Form einer Referenz inkludiert wurden, können jederzeit
durch Auswahl von Unterprojekt | Als Kopie inkludieren in "als Kopie" geändert
werden.
Bitte beachten Sie:
Alle inkludierten Projekte des Quellprojekts wurden ebenfalls inkludiert: Java Lang,
Unknown Externals und Java Profile.
Freigegebene Pakete - Objektbeziehungen zu externen Elementen:
Altova UModel 2017
© 2016 Altova GmbH
163
Wenn Sie versuchen, ein Paket freizugeben, das Objektbeziehungen zu externen Elementen
enthält, erscheint eine entsprechende Meldung, z.B. dass Sie versuchen, das Paket "BankView"
freizugeben.
Wenn Sie auf "Ja" klicken, werden die externen Objektbeziehungen aufgelöst, bevor Sie das
Projekt speichern können.
Im Meldungsfenster werden Informationen zu den einzelnen externen Objektbeziehungen
angezeigt.
Wenn Sie im Meldungsfenster auf eine Fehlermeldung klicken, wird das entsprechende Element
auf dem Register "Modell-Struktur" angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
164
Altova UModel 2017
© 2016 Altova GmbH
UML-Vorlagen
165
6.14 UML-Vorlagen
UModel unterstützt die Verwendung von UML-Vorlagen (Templates) und das Mappen dieser
Vorlagen auf oder von Java-, C#- und Visual Basic Generics.
Vorlagen (Templates) sind "potentielle" Modellelemente mit nicht gebundenen formalen
Parametern.
Diese parametrisierten Modellelemente beschreiben eine Gruppe von Modellelementen
eines bestimmten Typs: Classifier oder Operationen.
Vorlagen können nicht direkt als Typen verwendet werden. Die Parameter müssen
gebunden sein.
Instantiieren bedeutet, die Vorlagenparameter an aktuelle Werte zu binden.
Aktuelle Werte für Parameter sind Ausdrücke.
Durch die Bindung zwischen einer Vorlage und einem Modellelement wird ein neues
Modellelement (ein gebundenes Element) auf Basis der Vorlage erzeugt.
Bei Vorhandensein mehrerer einschränkender Classifier in C# können die
Vorlagenparameter direkt auf dem Register "Eigenschaften" bearbeitet werden, wenn der
Vorlagenparameter ausgewählt ist.
Anzeige der Vorlagensignatur in UModel:
Klassenvorlage mit dem Namen MyVector mit dem formalen Vorlagenparameter "T", der
in einem gestrichelten Rechteck angezeigt wird.
Formale Parameter ohne Typinfo (T ) sind implizit Classifier: Class, Datatype,
Enumeration, PrimitiveType, Interface. Alle anderen Parametertypen müssen explizit
angezeigt werden z.B. Integer.
Eigenschaft myArray mit einer unbeschränkten Anzahl an Elementen vom Typ T.
Wenn Sie mit der rechten Maustaste auf die Vorlage klicken und den Eintrag Anzeigen |
Gebundene Elemente auswählen, werden die gebundenen Elemente angezeigt.
Anzeige der Vorlagenverwendung:
eine gebundene benannte Vorlage intvector
Vorlage vom Typ MyVector, wobei
der Parameter T durch int ersetzt wird
"Ersetzt durch" wird angezeigt durch - >.
Verwendung von Vorlagen in Eigenschaften/Operationen:
Eine anonyme Vorlagenverwendung:
Eigenschaft MyFloatVector vom Typ MyVector<T->float>
© 2016 Altova GmbH
Altova UModel 2017
166
UML-Vorlagen
Vorlagen können auch beim Definieren von Eigenschaften oder Operationen definiert werden. Die
Autokomplettierungsfunktion hilft Ihnen, die Syntaxvorgaben einzuhalten.
Operation1 gibt einen Vektor von floats zurück.
Altova UModel 2017
© 2016 Altova GmbH
UML-Vorlagen
167
6.14.1 Vorlagensignaturen
Eine Vorlagensignatur ist ein String, der die formalen Vorlagenparameter definiert. Eine Vorlage
(Template) ist ein parametrisiertes Element, das zum Generieren neuer Modellelemente
verwendet wird, indem die formalen Parameter durch tatsächliche Parameter (Werte) ersetzt
werden bzw. daran gebunden werden.
Formaler Vorlagenparameter
T
Vorlage mit einem einzigen formalen Parameter, ohne Typenkonzept
(speichert Elemente vom Typ T)
Multiple formale Vorlagenparameter
KeyType:DateType, ValueType
Parameterersetzung
T>aBaseClass
Die Parametersubstitution muss vom Typ "aBaseClass" oder davon abgeleitet sein.
Standardwerte für Vorlagenparameter
T=aDefaultValue
Ersetzen von Classifiern
T>{contract}aBaseClass
allowsSubstitutable is true
Der Parameter muss ein Classifier sein, der an die Stelle des Classifiers gesetzt werden
kann, der durch den Classifier-Namen definiert ist.
Einschränken von Vorlagenparametern
T:Interface>anInterface
Wenn Sie Parameter auf etwas anderes als eine Klasse einschränken wollen
(Schnittstelle, Datentyp), wird die Einschränkung nach dem ":"-Zeichen angezeigt. So
wird T z.B. an eine Schnittstelle gebunden (T:Interface) die vom Typ
"anInterface" (>anInterface) sein muss.
Verwendung von Platzhalterzeichen in Vorlagensignaturen
T>vector<T->?<aBaseClass>
Der Vorlagenparameter T muss vom Typ "vector" sein, der Objekte enthält, die ein
übergeordneter Typ von aBaseClass sind.
Erweitern von Vorlagenparametern
T>Comparable<T->T>
© 2016 Altova GmbH
Altova UModel 2017
168
UML-Vorlagen
Bei der Vorlagenverwendung werden die formalen Parameter durch tatsächliche Werte ersetzt,
d.h. die Vorlage wird instantiiert. UModel generiert in diesem Fall automatisch anonym gebundene
Klassen. Vorlagenverwendungen können wie unten gezeigt im Klassennamen-Feld definiert
werden.
Ersetzen/Binden von formalen Parametern
Vektor <T->int>
Erstellen von Vorlagenverwendungen über den Klassennamen
a_float_vector:vector<T->float>
Binden von mehreren Vorlagen gleichzeitig
Class5:vector<T->int, map<KeyType->int, ValueType<T->int>
Verwendung von Platzhalterzeichen ? als Parameter (Java 5.0)
vector<T->?>
Einschränken von Platzhalterzeichen - upper bounds (UModel Erweiterung)
vector<T->?>aBaseClass>
Einschränken von Platzhalterzeichen - lower bounds (UModel Erweiterung)
vector<T->?<aDerivedClass>
Altova UModel 2017
© 2016 Altova GmbH
UML-Vorlagen
169
6.14.3 Vorlagenverwendung in Operationen und Eigenschaften
Operation, die eine gebundene Vorlage zurückgibt
Class1
Operation1():vector<T->int>
Der Parameter T ist an "int" gebunden. Operation1 gibt einen Vektor von ints zurück.
Klasse, die eine Vorlagenoperation enthält
Class1
Operation1<T>(in T):T
Verwenden von Platzhalterzeichen
Class1
Property1:vector<T->?>
Diese Klasse enthält einen generischen Vektor eines nicht spezifizierten Typs (? ist das
Platzhalterzeichen).
Typisierte Eigenschaften können als Assoziationen angezeigt werden:
Rechtsklicken Sie auf eine Eigenschaft und wählen Sie Anzeigen | PropertyX als
Assoziation oder
Ziehen Sie eine Eigenschaft auf den Diagrammhintergrund.
© 2016 Altova GmbH
Altova UModel 2017
170
Projekteinstellungen
6.15 Projekteinstellungen
Über diese Option können Sie die globale Projekteinstellungen definieren.
Wählen Sie den Menüeintrag Extras | Optionen, um Ihre lokalen Einstellungen zu definieren.
Nähere Informationen dazu finden Sie im Referenzteil unter Extras | Optionen.
Altova UModel 2017
© 2016 Altova GmbH
Verbesserung der Performance
171
6.16 Verbesserung der Performance
Da Modellierungsprojekte manchmal relativ groß werden können, gibt es Möglichkeiten, die
Performance beim Modellieren zu verbessern:
Stellen Sie sicher, dass Sie die neuesten Treiber für Ihre jeweilige Grafikkarte verwenden
(tun Sie dies, bevor Sie die folgenden Tipps befolgen)
Deaktivieren Sie die Syntaxfärbung - Register "Stile" | Syntaxfarben verwenden =
false.
Deaktivieren Sie "gradient" als Hintergrundfarbe für Diagramme, verwenden Sie eine
einheitliche Farbe. z.B: Register "Stile" | Diag. Hintergrundfarbe | Weiß.
Die automatisch aktivierte Autokomplettierung kann über Extras | Optionen |
Diagrambearbeitung und Deaktivieren des Kontrollkästchens "Automatische
Eingabehilfe aktivieren" deaktiviert werden.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 7
174
7
Modellbeziehungen können auf verschiedene Arten erstellt und in Diagramme eingefügt werden:
Mit Hilfe der Verbindungsziehpunkte. Ein Beispiel dazu finden Sie unter Use Cases.
Durch Klicken auf das entsprechende Symbol in der Symbolleiste und Ziehen der
Verbindungen zwischen den Elementen mittels Drag-and-Drop.
Assoziationssymbol
Aggregation
Komposition
Enthältbeziehung
Nachdem eine Assoziation erstellt wurde, wird automatisch ein neues Attribut in die
Ursprungsklasse (A:name) eingefügt, z.B. Property1:Class2 im unten stehenden Beispiel.
Nachdem die Assoziation erstellt wurde, ist sie aktiv und auf dem Register "Eigenschaften"
werden ihre Eigenschaften angezeigt. In einem Textlabel wird der Standardname des Member
End der Assoziation, also Property1 angezeigt. Beachten Sie: Über den Kontextmenübefehl
Textlabel... können Sie Textlabel ein- und ausblenden.
Wenn Sie auf eine Assoziationslinie klicken, werden die Eigenschaften der Assoziation auf dem
Register "Eigenschaften" angezeigt. A:Name und B:Name geben die Rolle der jeweiligen Klasse
in der anderen an.
Altova UModel 2017
© 2016 Altova GmbH
175
Je nach der Eigenschaft "memberEndKind" - (von A:name "Property1"):
gehört das Attribut entweder zur:
Klasse - d.h. A:memberEndKind = memberEnd, (Das Attribut wird in class1 angezeigt)
oder
Assoziation - d.h. B:memberEndKind = ownedEnd (Das Attribut wird in class2 nicht
angezeigt).
Wenn beide Attribute zur Assoziation gehören, d.h. wenn beide Enden als "ownedEnd"
definiert sind, wird diese Assoziation bidirektional und der Navigationspfeil verschwindet.
Beide Enden der Assoziation sind "ownedEnd".
Wenn "memberEndKind" einer der Assoziationen auf "navigableOwnedEnd gesetzt ist, ist das
Attribut weiterhin Teil der Assoziation, doch wird der Navigierbarkeitspfeil wieder angezeigt, je
nachdem an welchem Ende (A:name oder B:name) es gesetzt wurde.
So definieren Sie den Assoziationstyp (Assoziation, Aggregation oder Komposition)
1. Klicken Sie auf den Assoziationspfeil.
2. Scrollen Sie auf dem Register "Eigenschaften" hinunter zum Eintrag Aggregation.
3. Wählen Sie: none, shared oder composite.
none:
eine Standardassoziation
shared:
eine Aggregationsassoziation
composite: eine Kompositionsassoziation
Bitte beachten Sie:
Assoziationen können mit derselben Klasse als Quelle und Ziel erstellt werden. Dabei
handelt es sich um ein so genanntes "self link". Dies beschreibt die Fähigkeit eines
Objekts, bei rekursiven Aufrufen eine Nachricht an sich selbst zu senden.
Klicken Sie auf das Beziehungssymbol und ziehen Sie es anschließend vom Element an
eine andere Stelle desselben Elements. Daraufhin wird eine Objektbeziehung auf sich
selbst angezeigt.
Automatische Anzeige von Assoziationen in Diagrammen
© 2016 Altova GmbH
Altova UModel 2017
176
Beim Einfügen von Diagrammelementen in ein Diagramm können bestehende Assoziationen
zwischen Modellelementen mit Hilfe der Option "Assoziationen automatisch erstellen" von dem
Register Extras | Optionen | Bearbeiten automatisch im aktuellen Diagramm erstellt/angezeigt
werden. Dies geschieht, wenn der Typ des Attributs definiert ist und das referenzierte
Modellelement dieses Typs im aktuellen Diagramm vorhanden ist.
Löschen von Beziehungen/Assoziationen:
1. Klicken Sie auf dem Diagrammregister oder in der Modell-Struktur auf die Beziehung.
Die Abhängigkeit wird aus dem Diagramm und dem Projekt gelöscht.
Löschen von Klassenassoziationen:
Beim Löschen einer Klassenassoziation wird das/die automatisch generierte Attribut/
Eigenschaft nicht aus der Klasse gelöscht!
1. Rechtsklicken Sie in der Klasse auf das Attribut/die Eigenschaft.
2. Wählen Sie die Option "PropertyX von ClassX löschen" um sie zu löschen.
Erstellen von Assoziationsqualifiern:
1. Nachdem Sie eine Assoziation zwischen zwei Klassen definiert haben
2. Rechtsklicken Sie auf die Linie der Assoziation und wählen Sie den Befehl Neu |
Qualifier.
Beachten Sie bitte: Qualifier sind Attribute einer Assoziation.
Erstellen einer Enthältbeziehungsassoziation:
Mit Hilfe einer Enthältbeziehungsassoziation werden Beziehungen zwischen über- und
untergeordneten Elementen dargestellt.
1. Klicken Sie in der Titelleiste auf die Schaltfläche "Enthältbeziehung"
.
2. Ziehen Sie die Linie mit der Maus von der Klasse, die enthalten sein soll, auf die
enthaltende Klasse.
Beachten Sie, dass die enthaltene Klasse - in diesen Fall Class 2 - jetzt in einem
Bereich von Class1 zu sehen ist. Dadurch wird die enthaltene Klasse im Allgemeinen in
denselben Namespace platziert wie die enthaltende Klasse.
Altova UModel 2017
© 2016 Altova GmbH
7.1
Anzeigen von Modellbeziehungen
177
Anzeigen von Beziehungen zwischen Modellelementen:
1. Rechtsklicken Sie auf das entsprechende Element und wählen Sie den Befehl Anzeigen.
Das unten gezeigte Popup-Menü ist kontextspezifisch, d.h. es stehen nur die Optionen
zur Verfügung, die für das jeweilige Element relevant sind.
So zeigen Sie Textlabels an bzw. blenden sie aus:
Klicken Sie mit der rechten Maustaste auf eine Klasse oder einen Assoziationspfeil und
wählen Sie den Befehl Textlabels anzeigen | Alle Textlabels anzeigen
(ausblenden).
So zeigen Sie ein Klassenattribut/eine Klasseneigenschaft als Assoziation an:
1. Rechtsklicken Sie auf die Eigenschaft in der Klasse.
© 2016 Altova GmbH
Altova UModel 2017
178
2. Wählen Sie die Menüoption Anzeigen | "EigenschaftXX" als Assoziation.
Daraufhin wird die referenzierte Klasse eingefügt/geöffnet und die jeweilige Assoziation
wird angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
7.2
Assoziationen, Realisierungen und Abhängigkeiten
179
Erstellen von Beziehungen mit Hilfe von Verbindungsziehpunkten:
1. Angenommen, Sie haben zwei Klassen in einem Klassendiagramm,
2. Klicken Sie auf die erste Klasse, um sie zur aktiven zu machen.
Daraufhin werden an drei Seiten Verbindungsziehpunkte angezeigt.
3. Platzieren Sie den Mauszeiger über den oberen Ziehpunkt am rechten Rand der Klasse.
Daraufhin wird ein Tooltip mit Informationen über die Art der Beziehung, die mit diesem
Ziehpunkt erstellt wird, angezeigt - in diesem Fall "Assoziation".
4. Ziehen Sie, um eine Verbindungslinie zu erstellen, die Linie auf die zweite Klasse. Die
Zielklasse erscheint markiert, wenn diese Art von Assoziation zulässig ist.
Zwischen diesen beiden Klassen besteht nun eine Assoziation.
Beachten Sie, dass mit dem unteren Ziehpunkt des Klassenelements eine CollectionAssoziation erstellt wird.
Für die Elemente in den verschiedenen Modelldiagrammen stehen verschiedene
Verbindungsziehpunkte zur Verfügung.
So stehen z.B. bei einer Klasse in einem Klassendiagramm Ziehpunkte für die folgenden
Beziehungen zur Verfügung (im Uhrzeigersinn):
Schnittstellenrealisierung
Generalisierung
Assoziation
Ein Artefakt in der Deployment-Ansicht hat die folgenden Ziehpunkte:
Manifestation
Assoziation
Verteilung
Erstellen von Beziehungen mit Hilfe der Symbole der Symbolleiste:
Angenommen, Sie haben zwei Elemente in einem Modellierungsdiagramm,
1. Klicken Sie auf das Symbol, das die Beziehung darstellt, die Sie erzeugen möchten, z.B.
Assoziation, Aggregation, oder Komposition.
2. Ziehen Sie es von einem Objekt auf das andere und lassen Sie die Maustaste los, wenn
das Zielelement markiert erscheint.
© 2016 Altova GmbH
Altova UModel 2017
180
Beim Erstellen einer neuen Assoziation wird in die Ursprungsklasse (A:name)
automatisch ein neues Attribut eingefügt (Property1:Class2) - siehe Beispiel unten.
In UModel werden immer alle Attribute einer Klasse angezeigt!
Bitte beachten Sie:
In den Abbildungen in diesem Handbuch wird die Assoziation Ownership dot nicht
gezeigt.
Um diese zu aktivieren, setzen Sie Show Assoc. Ownership auf dem Register "Stile"
auf "true".
Löschen von Beziehungen/Assoziationen:
1. Klicken Sie auf dem Diagrammregister oder in der Modell-Struktur auf die Beziehung.
Die Abhängigkeit wird aus dem Diagramm und dem Projekt gelöscht.
Löschen von Klassenassoziationen:
Beim Löschen einer Klassenassoziation wird das/die automatisch generierte Attribut/
Eigenschaft nicht aus der Klasse gelöscht!
1. Rechtsklicken Sie in der Klasse auf das Attribut/die Eigenschaft.
2. Wählen Sie die Option "PropertyX von ClassX löschen", um das Attribut/die Eigenschaft
zu löschen.
Collection-Assoziationen
In UModel gibt es eine spezielle Art, Collection-Assoziationen anzuzeigen.
Collection-Assoziationen sind spezielle Assoziationen für Collection-Vorlagen. Eine
Klasseneigenschaft (z.B. Schnittstelle) kann im Allgemeinen als Assoziation zum "Typ" der
Eigenschaft angezeigt werden. UModel bietet zusätzlich dazu eine alternative Methode, um diese
Art von Assoziation anzuzeigen.
Klicken Sie auf den unteren der beiden Klassenziehpunkte auf der rechten Seite der Klasse und
ziehen Sie den Konnektor anschließend auf die Zielklasse.
Altova UModel 2017
© 2016 Altova GmbH
181
Wählen Sie den Collection-Typ im Popup-Menü aus.
Es wird eine andere Art von Assoziationspfeil erstellt.
Beispiel:
Wenn Assoziationen automatisch während des Reverse Engineering erstellt werden, sehen Sie
sie als Collection-Assoziationen, wenn die Einstellungen auf dem Register zur
Diagrammbearbeitung auf "Collections auflösen" gesetzt wurden und auch im Dialogfeld
"Collection-Vorlagen" zur Verfügung stehen.
Der Doppelpfeil zeigt an, dass der "Typ" von myColors nicht nur Color sondern eine "Collection
von" Colors ist.
Die Assoziation wird nicht als List<E->Color> angezeigt, sondern verweist direkt auf die
Enumeration "Color", wodurch die Information, dass Color in einem Template Binding verwendet
wird, nicht sichtbar ist.
Der konkrete Collection-Typ von "myColors" wird immer noch im myColorsContainer, nicht aber in
der Assoziation angezeigt.
Über das Register "Diagrammbearbeitung" des Dialogfelds Extras | Optionen können Sie die
Vorlagen definieren, in denen dieses Verhalten angewendet werden soll und ob die Collections
aufgelöst werden sollen.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 8
184
8
Altova Website:
UML-Projektdokumentation
Mit dem Befehl Dokumentation generieren wird detaillierte Dokumentation zu Ihrem UMLProjekt in den Formaten HTML, MS Word, RTF oder PDF generiert. Mit diesem Befehl generierte
Dokumentation kann beliebig geändert und verwendet werden; Sie benötigen dazu keine
Genehmigung von Altova.
Die Dokumentation wird für die Modellierungselemente generiert, die Sie im Dialogfeld
"Dokumentation generieren" ausgewählt haben. Sie können entweder das vordefinierte Design
verwenden oder ein StyleVision SPS für das Design verwenden. Bei Verwendung eines
StyleVision SPS können Sie die Ausgabe der generierten Dokumentation anpassen. Eine
Anleitung dazu finden Sie im Abschnitt Benutzerdefinierte Stylesheets.
Anmerkung: Bei Generierung von Dokumentation mit Hilfe eines SPS müssen Sie StyleVision
auf Ihrem Rechner installiert haben. Miteinander in Beziehung stehende Elemente sind in
der Bildschirmausgabe normalerweise durch einen Link verbunden, um die Navigation von
einer Komponente zur anderen zu erleichtern.
Um Dokumentation im Format MS Word zu generieren, muss MS Word (Version 2000
oder höher) installiert sein.
Wenn Sie ein UML-Projekt, z.B. Bank_Multilanguage.ump geöffnet haben:
1. Wählen Sie die Menüoption Projekt | Dokumentation generieren.
Daraufhin wird das Dialogfeld "Dokumentation generieren" geöffnet. In der Abbildung unten
sehen Sie die Standardeinstellungen des Dialogfelds.
Altova UModel 2017
© 2016 Altova GmbH
185
Beachten Sie: Sie können auch einzelne Teile eines Projekts dokumentieren. Rechtsklicken
Sie dazu in der Modellstruktur auf ein Element (bzw. mit Strg + Klick auf mehrere Elemente) und
wählen Sie den Befehl "Dokumentation generieren". Beim Element kann es sich um einen Ordner,
eine Klasse, eine Schnittstelle usw. handeln. Die Dokumentationsoptionen sind in beiden Fällen
dieselben.
Miteinander in Beziehung stehende Elemente werden in der Ausgabe auf dem Bildschirm durch
Hyperlinks miteinander verbunden, sodass Sie von Komponente zu Komponente navigieren
können. In der Dokumentation sind auch alle manuell erstellten Hyperlinks enthalten.
Beachten Sie außerdem, dass Dokumentation auch für inkludierte C#-, Java- und/oder VBUnterprojekte (Profile) generiert wird, wenn diese Optionen auf dem Register "Inkludieren"
ausgewählt ist.
Register "Hauptbereich":
Dokumentationserstellung
Wählen Sie die Option "Festgelegtes Design ...verwenden" um die vordefinierte
Dokumentationsvorlage zu verwenden.
Wählen Sie die Option "Für ein benutzerdefiniertes Design..." um ein vordefiniertes, in
StyleVision erstelltes StyleVision Power Stylesheet zu verwenden. Die SPS-Dateien
finden Sie im Ordner ...\My Documents\Altova\UModel2017\Documentation\UModel\
.
Klicken Sie auf Durchsuchen um zu einer vordefinierten SPS-Datei zu navigieren.
Klicken Sie auf Bearbeiten, um StyleVision zu starten und das ausgewählte SPS in
einem StyleVision-Fenster zu öffnen.
Ausgabeformat:
Hier wird das Ausgabeformat definiert: entweder HTML, Microsoft Word, RTF oder PDF.
Microsoft Word-Dokumente werden mit der Dateierweiterung .doc angelegt, wenn sie
anhand eines festgelegten Designs erstellt werden, und mit der Dateierweiterung .docx,
wenn sie anhand eines StyleVision SPS generiert werden.
Das Ausgabeformat PDF steht nur zur Verfügung, wenn Sie die Dokumentation anhand
eines StyleVision SPS generieren.
Mit der Option Ausgabe auf mehrere Dateien aufteilen wird für jedes
Modellierungselement, das bei Generierung einer einzigen Ausgabedatei in der
Inhaltsverzeichnisübersicht zu sehen ist, eine Ausgabedatei erstellt. Z.B. gibt es eine
Klasse C1 mit einer geschachtelten Klasse CNest; C1.html enthält alle Informationen zu
C1 und CNest sowie alle ihre Attribute und Eigenschaften usw.
Mit der Option CSS in HTML einbetten können Sie eine vorhandene (referenzierte) CSSDatei in die HTML-Dokumentation einbetten. Wenn Sie die Option deaktivieren, wird die
Referenz zur CSS-Datei beibehalten und die Datei selbst bleibt extern.
Die Option Diagramme einbetten ist für die Ausgabeoptionen MS Word und RTF
aktiviert. Wenn diese Option ausgewählt ist, werden Diagramm in die generierte Datei
eingebettet. Diagramme werden als PNG-Dateien (für HTML) oder PNG/EMF-Dateien (für
MS Word und RTF) erstellt und über Objektlinks in der Ergebnisdatei angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
186
Mit der Option Ordner für Diagramme erstellen wird unterhalb des ausgewählten
Ausgabeordners ein Unterordner erstellt, der bei Ausgabe der Dokumentation alle
Diagramme enthält.
´
Die Option Ergebnisdatei...anzeigen ist für alle Ausgabeoptionen aktiviert. Wenn die
Option aktiv ist, werden die Ergebnisdateien in der Browser-Ansicht (HTML-Ausgabe), MS
Word (MS Word-Ausgabe) und der Standardapplikation für .rtf-Dateien (RTF-Ausgabe)
angezeigt.
Über die Option Links zu lokalen Dateien generieren können Sie festlegen, ob die
generierten Links absolute oder relative Links zur Ausgabedatei sein sollen.
Register "Inkludieren"
Auf dem Register Inkludieren können Sie auswählen, welche Diagramme und
Modellierungselemente in der Dokumentation aufscheinen sollen.
Beachten Sie, dass die Dokumentation von Unterprojekten durch Auswahl des Kontrollkästchens
"Inkludierte Unterprojekte" deaktiviert werden kann.
Register "Details"
Auf dem Register Details können Sie die Elementdetails auswählen, die in der Dokumentation
aufscheinen sollen.
Wenn Sie den Text von XML-Tags in Ihre Dokumentation importieren möchten,
deaktivieren Sie bitte unter der Dokumentationsoption die Option "als HTML".
In den Feldern "Nach oben" / "Nach unten" können Sie die Verschachtelungstiefe
festlegen, die im Hierarchiediagramm oberhalb / unterhalb der aktuellen Klasse angezeigt
werden soll.
Mit der Option "Jedes Element nur einmal erweitern" wird nur immer jeweils ein Classifier
Altova UModel 2017
© 2016 Altova GmbH
187
im selben Bild/Diagramm erweitert.
Register "Schriftarten"
Auf dem Register "Schriftarten" können Sie die Schriftarteinstellungen für die verschiedenen
Überschriften und Textinhalte anpassen.
© 2016 Altova GmbH
Altova UModel 2017
188
In den folgenden Abbildungen sehen Sie die mit dem festgelegten Design generierte
Dokumentation für die Datei Bank_MultiLanguage.ump aus dem Verzeichnis ...
\UModelExamples.
In der Abbildung oben sehen Sie die generierte Dokumentation mit den Diagramm- und
Elementindexlinks in oberen Bereich der HTML-Datei.
Altova UModel 2017
© 2016 Altova GmbH
189
In der Abbildung unten sehen Sie die näheren Informationen zur Klasse "Account" sowie ihre
Beziehung zu anderen Klassen.
Beachten Sie, dass die einzelnen Attribute und Eigenschaften in den Klassendiagrammen
ebenfalls mittels Hyperlinks mit ihren Definitionen verknüpft sind. Wenn Sie auf eine Eigenschaft
klicken, gelangen Sie zu ihrer Definition. Die einzelnen Hierarchieklassen sowie der gesamte
unterstrichene Text sind durch Hyperlinks verbunden.
© 2016 Altova GmbH
Altova UModel 2017
190
8.1
Vordefiniertes SPS-Stylesheet
Vordefiniertes SPS-Stylesheet
So generieren Sie Dokumentation auf Basis der vordefinierten SPS-Datei:
1. Wählen Sie die Menüoption Projekt | Dokumentation generieren.
2. Aktivieren Sie das Optionsfeld "Für ein benutzerdefiniertes Design...".
3. Wählen Sie im Dialogfeld "Dokumentation generieren" das Stylesheet
UModelDocumentation.sps aus.
Sie werden nun aufgefordert, die Datei zu speichern.
4. Geben Sie den Dateinamen ein und wählen Sie den gewünschten Speicherpfad aus.
Wenn Sie in der generierten Dokumentation auf einen Link klicken, gelangen Sie zum
entsprechenden Modellierungselement im Browser.
Altova UModel 2017
© 2016 Altova GmbH
8.2
Benutzerdefinierte Stylesheets
191
Benutzerdefinierte Stylesheets
Anstatt das festgelegte Design zu verwenden, können Sie auch ein benutzerdefiniertes Design für
die UModel-Dokumentation erstellen. Das benutzerdefinierte Design wird in einem StyleVision
SPS erstellt. Beachten Sie, dass das vordefinierte SPS Stylesheet bereits im Lieferumfang von
UModel inkludiert ist.
Definition des SPS für die Verwendung für die UModel-Dokumentation
Das SPS, das für die Generierung der Dokumentation verwendet werden soll, wird im Dialogfeld
"Dokumentation generieren" (Aufruf mit dem Befehl Projekt | Dokumentation generieren)
definiert. Aktivieren Sie das Optionsfeld "Benutzerdefiniertes Design verwenden...".
Standardmäßig ist UModelDocumentation.sps ausgewählt.
Die vordefinierte SPS-Datei befindet sich im Ordner ...\Documentation\UModel.
Bitte beachten Sie:
Damit Sie ein SPS für die Dokumentationsgenerierung verwenden können, muss
StyleVision auf Ihrem Rechner installiert sein.
Erstellung des SPS
Ein StyleVision Power Stylesheet (oder SPS) wird mit dem Altova-Produkt StyleVision generiert.
Ein SPS zum Generieren von UModel-Dokumentation muss auf dem XML-Schema basieren, das
die Struktur des XML-Dokuments definiert, das die UModel-Dokumentation enthält.
Dieses Schema hat den Namen UModelDocumentation.xsd und ist in Ihrem UModelInstallationspaket enthalten. Es befindet sich im Ordner ...\My Documents\Altova\UModel2017
\Documentation\UModel.
Bei Erstellung des SPS-Designs in StyleVision werden Nodes aus dem Schema
UModelDocumentation.xsd in das Design gezogen und diese Nodes erhalten Stile und
Eigenschaften zugewiesen. Beachten Sie, dass UModelDocumentation.xsd die Datei
Documentation.xsd aus dem übergeordneten Ordner enthält.
Des Weiteren können zusätzliche Komponenten wie z.B. Links und Bilder ebenfalls zum SPSDesign hinzugefügt werden. Eine Anleitung zur Erstellung eines SPS Designs in StyleVision
finden Sie im Benutzerhandbuch zu StyleVision.
Der Vorteil bei der Generierung der Dokumentation anhand eines SPS ist, dass Sie völlig freie
Hand bei der Gestaltung der Dokumentation haben. Beachten Sie außerdem, dass die PDFAusgabe der Dokumentation nur bei Verwendung eines SPS zur Verfügung steht; bei Verwendung
des festgelegten Designs steht die PDF-Ausgabe nicht zur Verfügung.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 9
UML-Diagramme
194
UML-Diagramme
9
UML-Diagramme
UML-Diagramme werden in zwei große Gruppen eingeteilt: Strukturdiagramme, in denen eine
statische Ansicht des Modells zu sehen ist, und Verhaltensdiagramme, in denen die dynamische
Ansicht dargestellt wird. UModel unterstützt alle vierzehn Diagramme der UML 2.4-Spezifikation
sowie XML-Schema- und Business Modeling Notation-Diagramme.
Zu den Verhaltensdiagrammen gehören Aktivitäts-, Zustands-, Protokoll-Zustands- und Use CaseDiagramme sowie Interaktionsdiagramme Kommunikations-, Interaktionsübersichtsdiagramme,
Sequenzdiagramme und Zeitverlaufsdiagramme.
Zu den Strukturdiagrammen gehören: Klassen-, Kompositionsstruktur-, Komponenten-,
Deployment-, Objekt- und Paketdiagramme.
Zusätzliche Diagramme: XML-Schema-Diagramme.
Bitte beachten Sie:
Mit Strg+Eingabetaste können Sie mehrzeilige Beschriftungen für die meisten
Modellierungsdiagramme erstellt werden, z.B. Lebenslinienbeschriftungen in
Sequenzdiagrammen, Zeitverlaufsdiagrammen; Guard-Bedingungen, Zustandsnamen,
Aktivitätsnamen usw.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.1
Verhaltensdiagramme
195
Verhaltensdiagramme
In diesen Diagrammen werden Verhaltensaspekte eines Systems oder Geschäftsvorgangs
beschrieben. Sie enthalten eine Untergruppe von Diagrammen zur Darstellung der
Wechselbeziehungen zwischen Objekten.
Verhaltensdiagramme
Aktivitätsdiagramm
Zustandsdiagramm
Protokoll-Zustandsdiagramm
Use Case-Diagramm
Eine Untergruppe der Verhaltensdiagramme bilden jene zur Darstellung von Wechselwirkungen
zwischen Objekten:
Sequenzdiagramm
© 2016 Altova GmbH
Altova UModel 2017
196
UML-Diagramme
9.1.1
Aktivitätsdiagramm
Altova Website:
Verhaltensdiagramme
UML-Aktivitätsdiagramm
Aktivitätsdiagramme eignen sich, um reale Arbeitsabläufe von Geschäftsprozessen zu modellieren
und um anzuzeigen, welche Aktionen dabei erforderlich sind und welche Abhängigkeiten diese
haben. Im Aktivitätsdiagramm wird die Reihenfolge von Aktivitäten beschrieben. Es wird sowohl
bedingte als auch parallele Verarbeitung unterstützt. Das Aktivitätsdiagramm ist eine Variante des
Zustandsdiagramms, wobei die Zustände hier Aktivitäten sind.
Bitte beachten Sie, dass das im folgenden Abschnitt gezeigte Aktivitätsdiagramm im UModelOrdner ...\UModelExamples im Beispiel Bank_MultiLanguage.ump zur Verfügung steht.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
197
Einfügen von Aktivitätsdiagrammelementen
Verwendung der Symbolleistenschaltflächen:
1. Klicken Sie in der Aktivitätsdiagrammsymbolleiste auf das gewünschte
Aktivitätsdiagramm-Symbol.
2. Klicken Sie in das Aktivitätsdiagramm, um das Element einzufügen. Um mehrere
Elemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt und
klicken Sie in das Diagrammfenster.
Ziehen bestehender Elemente in das Aktivitätsdiagramm:
Die meisten Elemente, die in anderen Aktivitätsdiagrammen vorkommen, können in ein
bestehendes Aktivitätsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (Sie können
das Element über das Suchfunktionstextfeld oder mit Hilfe von Strg + F suchen).
2. Ziehen Sie das/die Element(e) in das Aktivitätsdiagramm.
Einfügen einer Aktion (Aufrufverhalten):
1. Klicken Sie in der Symbolleiste auf das Symbol Aktion (Aufrufverhalten)
und
anschließend in das Aktivitätsdiagramm, um es einzufügen.
2. Geben Sie den Namen der Aktion ein, z.B. "Validate References" (=Referenzen
validieren) und drücken Sie zur Bestätigung die Eingabetaste.
Anmerkung: Durch Drücken von Strg+Eingabetaste können Sie einen mehrzeiligen
Namen erstellen.
Einfügen einer Aktion (Aufrufoperation) und Auswählen einer bestimmten Operation:
1. Klicken Sie in der Symbolleiste auf das Symbol "Aktion (Aufrufoperation)"
und
anschließend in das Aktivitätsdiagramm um es einzufügen.
2. Geben Sie den Namen der Aktion ein, z.B. collectAccountInfo und drücken Sie zur
Bestätigung die Eingabetaste.
3. Klicken Sie auf dem Register "Eigenschaften" auf die Durchsuchen-Schaltfläche rechts
vom Feld "Operation".
© 2016 Altova GmbH
Altova UModel 2017
198
UML-Diagramme
Verhaltensdiagramme
Daraufhin wird das Dialogfeld "Operation auswählen" geöffnet. Hier können Sie die
gewünschte Operation auswählen.
4. Navigieren Sie zur gewünschten Operation und bestätigen Sie die Auswahl mit OK.
In diesem Beispiel befindet sich die Operation "collectAccountInfos" in der Klasse
"BankView".
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
199
Erstellen von Verzweigungen und Merges
Erstellen einer Verzweigung (alternativer Fluss)
Eine Verzweigung hat einen einzigen eingehenden Fluss und mehrere mit "Guards" versehene
ausgehende Flüsse. Es kann nur einer der ausgehenden Flüsse ausgewählt werden, daher sollten
die Guards einander gegenseitig ausschließen.
In diesem Beispiel müssen die (BankView) Referenzen validiert werden.
branch1 (Verzweigung1) hat den Guard "reference missing" (=Referenz fehlt). Diese
Transition endet im Abbruch der Aktivität.
branch2 hat den Guard "valid" (= gültig). Diese Transition führt zur Aktivität
collectAccountInfos (Kontoinformationen abrufen).
1. Klicken Sie in der Symbolleiste auf das Symbol Verzweigungsknoten
Sie das Element im Aktivitätsdiagramm ein.
und fügen
2. Klicken Sie auf das Symbol "Aktivitätsendknoten"
, welches für die Aktivität
"Abbruch" steht und fügen Sie es in das Aktivitätsdiagramm ein.
3. Klicken Sie auf die Aktivität "Validate References", um sie auszuwählen, anschließend
auf den rechten Ziehpunkt Kontrollfluss und ziehen Sie den Konnektor, der angezeigt
wird, auf das Verzweigungsknoten-Element.
Sobald das Element markiert angezeigt wird, können Sie die Maustaste loslassen.
4. Klicken Sie auf das Verzweigungsknoten-Element, klicken Sie auf den rechten
Konnektor Kontrollfluss und ziehen Sie ihn auf die Aktion "collectAccountInfos". Nähere
Informationen dazu finden Sie unter "Einfügen einer Aktion (Aufrufoperation)".
© 2016 Altova GmbH
Altova UModel 2017
200
UML-Diagramme
Verhaltensdiagramme
5. Geben Sie auf dem Register "Eigenschaften" die Guard-Bedingung "valid" ein.
6. Klicken Sie auf das Verzweigungsknotenelement und ziehen Sie den rechten
Ziehpunkt Kontrollfluss auf das Element "Aktivitätsendknoten".
Die Guard-Bedingung zu dieser Transition wird automatisch als "else" definiert.
Doppelklicken Sie im Diagramm auf die Guard-Bedingung und ändern Sie diese z.B. in
"reference missing".
Bitte beachten Sie, dass UModel die Anzahl der Kontroll- / Objektflüsse in einem Diagramm nicht
validiert oder überprüft.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
201
Erstellen eines Merge:
1. Klicken Sie in der Symbolleiste auf das Verbindungsknotensymbol
anschließend in das Aktivitätsdiagramm, um es einzufügen.
und
2. Klicken Sie auf die Kontrollfluss (Objektfluss)-Ziehpunkte der zu vereinigenden Aktionen
und ziehen Sie die Pfeile auf das Verbindungsknotensymbol.
Aktivitätsdiagramm-Elemente
Aktion (Aufrufverhalten)
Fügt das Aktionselement Aufrufverhalten ein, welches ein bestimmtes Verhalten direkt aufruft.
Wenn Sie über die Auswahlliste Verhalten ein vorhandenes Verhalten auswählen, z.B.
HandleDisplayException, wird innerhalb des Elements das Symbol eines Rechens angezeigt.
Aktion (Aufrufoperation)
Fügt die Aktion "Aufrufverhalten" ein, welche ein bestimmtes Verhalten als Methode direkt aufruft.
Nähere Informationen finden Sie unter "Einfügen einer Aktion (Aufrufoperation)".
Aktion (OpaqueAction)
Eine Art von Aktion, mit der Implementierungsinformationen definiert werden. Kann als Platzhalter
© 2016 Altova GmbH
Altova UModel 2017
202
UML-Diagramme
Verhaltensdiagramme
verwendet werden, bis fest steht, welche spezifische Aktion verwendet werden soll.
Aktion (ValueSpecificationAction)
Eine Art von Aktion zum Auswerten (/Generieren)
Ereignisannahmeaktion
Fügt die Ereignisannahmeaktion ein, welche auf das Eintreten eines Ereignisses wartet, das
bestimmte Bedingungen erfüllt.
Ereignisannahmeaktion (Zeitereignis)
Fügt eine Ereignisannahmeaktion ein, die durch ein Zeitereignis ausgelöst wird, welches ein
Zeitintervall - z.B. 1 sec since last update - mit einem Ausdruck definiert.
Signalsendeaktion
Fügt die Signalsendeaktion ein. Dabei wird ein Signal von den Inputs erstellt. Dieses Signal wird
an das Zielobjekt übertragen, wo es die Ausführung einer Aktivität auslösen kann.
Verzweigungsknoten
Fügt einen Verzweigungsknoten ein, welcher eine einzige eingehende Transition hat und mehrere
ausgehende mit Guards versehene Transitionen. Nähere Informationen dazu finden Sie unter
"Erstellen einer Verzweigung".
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
203
Verbindungsknoten
Fügt einen Verbindungsknoten ein, der mehrere durch einen Verzweigungsknoten definierte
alternative Transitionen zusammenführt. Die gleichzeitig ablaufenden Prozesse werden dabei nicht
synchronisiert, sondern es wird einer der Prozesse ausgewählt.
Startknoten
Der Anfang der Aktivität. Eine Aktivität kann mehrere Startknoten haben.
Aktivitätsendknoten
Das Ende der Aktivität. Eine Aktivität kann mehrere Endknoten haben. Alle Flüsse in der Aktivität
werden beendet, wenn der "erste" Endknoten erreicht wird.
Endknoten für Kontrollflüsse
Fügt den Endknoten für Kontrollflüsse ein, d.h. ein Fluss wird dadurch beendet. Diese Beendung
hat keinen Einfluss auf andere Flüsse in der Aktivität.
Parallelisierungsknoten
Fügt einen vertikalen Parallelisierungsknoten ein.
Dient zum Aufteilen von Flüssen in mehrere gleichzeitige Flüsse.
Parallelisierungsknoten (horizontal)
Fügt einen horizontalen Parallelisierungsknoten ein.
Dient zum Aufteilen von Flüssen in mehrere gleichzeitige Flüsse.
Synchronisationsknoten
Ein Synchronisationsknoten synchronisiert mehrere durch einen Parallelisierungsknoten definierte
Flüsse.
Synchronisationsknoten (horizontal)
© 2016 Altova GmbH
Altova UModel 2017
204
UML-Diagramme
Verhaltensdiagramme
Ein Synchronisationsknoten synchronisiert mehrere durch einen Parallelisierungsknoten definierte
Flüsse.
InputPin
Fügt einen Input Pin in ein Aufrufverhalten oder eine Aufrufoperation ein. Input Pins liefern
Eingabewerte, die von einer Aktion verwendet werden. Ein Input Pin erhält automatisch den
Standardnamen "argument".
Das Input Pin-Symbol kann nur auf jene Aktivitätselemente platziert werden, bei denen der
Mauszeiger sich in das Symbol einer Hand verwandelt
. Wenn Sie das Symbol mit der Maus
ziehen, wird es am Rand des Elements neu positioniert.
OutputPin
Fügt eine Output Pin-Aktion ein. Output Pins enthalten Werte, die von einer Aktion erzeugt
werden. Dem Output Pin wird automatisch ein Name zugewiesen, der der UML-Eigenschaft dieser
Aktion - z.B. "result" - entspricht.
Das Output Pin-Symbol kann nur auf jene Aktivitätselemente platziert werden, bei denen der
Mauszeiger sich in eine Hand verwandelt
. Wenn Sie das Symbol mit der Maus ziehen, wird
es am Rand des Elements neu positioniert.
Ausnahmepin
Ein Output Pin kann durch Klicken auf den Pin und Auswahl der Option "isExceptionPin" im
Fenster "Eigenschaften" in einen Ausnahmepin umgewandelt werden.
Wertpin
Fügt einen Wertpin ein. Dabei handelt es sich um einen Input Pin, der für eine Aktion einen Wert
bereitstellt, der nicht aus einem eingehenden Objektfluss stammt. Er wird als ein Input PinSymbol dargestellt und hat dieselben Eigenschaften wie ein Input Pin.
Objektknoten
Fügt einen Objektknoten ein. Ein Objektknoten ist ein abstrakter Aktivitätsknoten, der den
Objektfluss in einer Aktivität definiert. Objektknoten können nur Werte zur Laufzeit enthalten, die
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
205
dem Typ des Objektknotens entsprechen.
Pufferknoten
Fügt einen Pufferknoten ein, der als Puffer für mehrere eingehende und ausgehende Flüsse von
anderen Objektknoten dient.
Datenspeicherknoten
Fügt einen Datenspeicherknoten ein. Dabei handelt es sich um einen speziellen Pufferknoten, der
zum Speichern dauerhafter (d.h. nicht temporärer) Daten dient.
Aktivitätsbereich (horizontal)
Fügt einen horizontalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art von
Aktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaften gemeinsam
haben. Dies entspricht oft Organisationseinheiten in einem Geschäftsmodell.
Wenn Sie auf eine Beschriftung doppelklicken, lässt sich diese direkt editieren; bei Drücken der
Eingabetaste wird der Text korrekt ausgerichtet.
Bitte beachten Sie, dass Aktivitätsbereiche in UML 2.0 neu eingeführt wurden und die "swimlane"
Funktion früherer UML-Versionen ersetzen.
Elemente, die innerhalb einer ActivityPartition platziert werden, werden Teil davon, sobald die
Umrandung markiert erscheint.
Objekte innerhalb einer ActivityPartition können mit Hilfe von Strg+Klick oder durch
Aufziehen eines Rechtecks in der Umrandung einzeln ausgewählt werden.
Klicken Sie auf die Umrandung oder den titel der ActivityPartition und ziehen Sie sie/ihn,
um diese an eine andere Stelle zu verschieben.
Aktivitätsbereich (vertikal)
Fügt einen vertikalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art von
haben. Dies entspricht oft Organisationseinheiten in einem Geschäftsmodell.
© 2016 Altova GmbH
Altova UModel 2017
206
UML-Diagramme
Verhaltensdiagramme
Aktivitätsbereich (2 Dimensionen)
Fügt einen zweidimensionalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art von
haben. Beide Achsen haben editierbare Beschriftungen.
So entfernen Sie die Dim1, Dim2-Beschriftungen:
1. Klicken Sie auf die Dimensionsbezeichnung, die Sie entfernen möchten z.B. Dim1
2. Doppelklicken Sie auf dem Register "Eigenschaften" auf den Eintrag Dim1, löschen Sie
ihn und bestätigen Sie den Vorgang mit der Eingabetaste.
Beachten Sie, dass Aktivitätsbereiche geschachtelt sein können:
1. Rechtsklicken Sie auf die Beschriftung, wo Sie einen neuen Bereich einfügen möchten.
2. Wählen Sie Neu | Aktivitätsbereich.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
207
Kontrollfluss
Ein Kontrollfluss ist eine Kante, d.h. ein Pfeil, der zwei Aktivitäten/Verhalten verbindet und eine
Aktivität startet, nachdem die vorherige zu Ende geführt wurde.
Objektfluss
Ein Objektfluss ist eine Kante, d.h. ein Pfeil, der zwei Aktionen/Objektknoten verbindet und eine
Aktivität startet, sobald die vorherige zu Ende geführt worden ist. Entlang eines Objektflusses
können Objekte oder Daten übergeben werden.
Ausnahme-Handler
Ein Ausnahme-Handler ist ein Element, das festlegt, welche Aktion ausgeführt werden soll, wenn
während der Ausführung des geschützten Knotens ein bestimmtes Ausnahmeereignis auftritt.
© 2016 Altova GmbH
Altova UModel 2017
208
UML-Diagramme
Verhaltensdiagramme
Ein Ausnahme-Handler kann nur auf einen Inputpin einer Aktion gezogen werden.
Aktivität
Fügt eine Aktivität in das Aktivitätsdiagramm ein.
Aktivitätsparameterknoten
Fügt einen Aktivitätsparameterknoten in eine Aktivität ein. Wenn Sie an eine beliebige Stelle in
der Aktivität klicken, wird der Parameterknoten auf den Rand der Aktivität platziert.
StrukturierterAktivitätsknoten
Fügt einen strukturierten Aktivitätsknoten ein. Dabei handelt es sich um einen strukturierten Teil
der Aktivität, der mit keinem anderen strukturierten Knoten geteilt wird.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
209
Mengenverarbeitungsbereich
Ein Mengenverarbeitungsbereich ist ein Bereich einer Aktivität mit expliziten Inputs und Outputs
(über Erweiterungsknoten). Jeder Input ist eine Sammlung von Werten.
Der Mengenverarbeitungsbereichsknoten wird als Schlüsselwort angezeigt und kann durch
Klicken auf die Auswahlliste "Modus" auf dem Register "Eigenschaften" geändert werden. Zur
Auswahl stehen die Einstellungen: parallel, iterative oder stream.
Erweiterungsknoten
Fügt einen Erweiterungsknoten in einen Mengenverarbeitungsbereich ein. Erweiterungsknoten
sind Eingabe- und Ausgabeknoten für den Mengenverarbeitungsbereich, wobei jeder Input/Output
eine Sammlung von Werten ist. Die Pfeile, die in den Mengenverarbeitungsbereich hinein oder
daraus heraus weisen , legen die jeweilige Art des Erweiterungsknotens fest.
Unterbrechungsbereich
© 2016 Altova GmbH
Altova UModel 2017
210
UML-Diagramme
Verhaltensdiagramme
Ein Unterbrechungsbereich enthält Aktivitätsknoten. Wenn ein Kontrollfluss einen
Unterbrechungsbereich verlässt, werden alle Flüsse und Verhalten im Bereich beendet.
So fügen Sie eine InterruptingEdge hinzu:
Stellen Sie sicher dass:
der Unterbrechungsbereich ein Aktionselement sowie einen ausgehenden Kontrollfluss zu
einer anderen Aktion enthält:
1. Rechtsklicken Sie auf den Kontrollflusspfeil und wählen Sie Neu | InterruptingEdge.
Bitte beachten Sie:
Sie können eine InterrupingEdge auch durch Klicken auf den Unterbrechungsbereich,
Rechtsklick in das Fenster "Eigenschaften" und Auswahl des Popup-Menübefehls
"InterruptingEdge hinzufügen" hinzufügen.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.1.2
Verhaltensdiagramme
211
Zustandsdiagramm
Altova Website:
UML-Zustandsdiagramme
Im Zustandsdiagramm wird das Verhalten eines Systems modelliert, indem die Zustände, in
denen sich ein Objekt befinden kann und die Übergänge zwischen diesen Zuständen, beschrieben
werden. Im Allgemeinen dienen diese Diagramme dazu, das Verhalten eines Objekts in
verschiedenen Anwendungsfällen (Use Cases) zu beschreiben. Ein Zustandsautomat kann in
UModel beliebig viele Zustandsdiagramme haben.
Dies kann in Form von zwei Arten von Prozessen erfolgen:
Aktionen, die mit Transitionen verknüpft sind, sind kurzfristige Prozesse, die nicht unterbrochen
werden können, z.B. eine Start-Transition, ein interner Fehler / Admin benachrichtigen.
Zustandsaktivitäten (Verhalten), welche mit Zuständen verknüpft sind, sind länger andauernde
Prozesse, die durch andere Ereignisse unterbrochen werden können, z.B. das Warten auf
Verbindungsaufbauanfragen.
Beachten Sie, dass die in den folgenden Abschnitten gezeigten Zustandsdiagramme im UModel
Ordner ...\UModelExamples im Beispiel Bank_MultiLanguage zur Verfügung stehen.
© 2016 Altova GmbH
Altova UModel 2017
212
UML-Diagramme
Verhaltensdiagramme
Einfügen von Zustandsdiagrammelementen
Einfügen über die Symbole der Symbolleiste:
1. Klicken Sie in der Zustandsdiagramm-Symbolleiste auf das entsprechende
Zustandsdiagramm-Symbol.
2. Klicken Sie in das Zustandsdiagramm, um das Element einzufügen. Um mehrere
Ziehen von bestehenden Elementen in das Zustandsdiagramm:
Die meisten Elemente, die in anderen Zustandsdiagrammen vorkommen, können in ein
bestehendes Zustandsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register Modell-Struktur (Sie können dazu
das Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einem beliebigen
Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Zustandsdiagramm.
Erstellen von Zuständen, Aktivitäten und Transitionen
So fügen Sie einen einfachen Zustand hinzu:
1. Klicken Sie in der Symbolleiste auf das Symbol Zustand (
) und anschließend in das
Diagramm.
2. Geben Sie den Namen des Zustands ein und drücken Sie zur Bestätigung die
Eingabetaste.
So fügen Sie eine Aktivität zu einem Zustand hinzu:
Rechtsklicken Sie auf das Element "Zustand", wählen Sie "Neu" und anschließend einen
der Einträge aus dem Kontextmenü.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
213
Die Aktivitäten Eintritt, Austritt und Do sind mit einem der folgenden möglichen Verhalten
verknüpft: "Aktivität", "Interaktion" und "Zustandsautomat". Daher stehen im Kontextmenü die
folgenden Optionen zur Verfügung:
Austritt: Aktivität
Austritt: Interaktion
Austritt: Zustandsautomat
Do: Aktivität
Do: Interaktion
Do: Zustandsautomat
Eintritt: Aktivität
Eintritt: Interaktion
Eintritt: Zustandsautomat
Diese Optionen stammen aus der UML-Spezifikation. Bei jeder dieser internen Aktionen handelt
es sich um ein Verhalten und in der UML-Spezifikation sind drei Klassen von der Klasse
"Behavior" (Verhalten) abgeleitet: Activity (Aktivität), StateMachine (Zustandsautomat) und
Interaction (Interaktion). Es macht im generierten Code keinen Unterschied, welches spezifische
Verhalten (Aktivität, Zustandsautomat oder Interaktion) ausgewählt wurde.
Sie haben die Wahl zwischen Aktionen aus der Kategorie: Eintritts, Austritt und Do. Aktivitäten
werden im Zustandselement in ihren eigenen Bereich - wenn auch nicht in eine separate Region platziert. Die Art der ausgewählten Aktivität wird als Präfix für die Aktivität verwendet z.B: entry /
store current time (=Eintritt / aktuelle Zeit speichern).
© 2016 Altova GmbH
Altova UModel 2017
214
UML-Diagramme
Verhaltensdiagramme
So löschen Sie eine Aktivität:
Klicken Sie auf die entsprechende Aktivität im Zustandselement und drücken Sie die
Entf-Taste.
So erstellen Sie eine Transition zwischen zwei Zuständen:
1. Klicken Sie auf den Transition-Ziehpunkt des Ausgangszustands (auf der rechten Seite
des Elements).
2. Ziehen Sie den Transition-Pfeil mit der Maus auf den Ziel-Zustand.
Die Eigenschaften der Transition werden nun auf dem Register "Eigenschaften"
angezeigt. Wenn Sie auf die Auswahlliste "Art" klicken, können Sie den Typ der
Transition definieren: extern, intern oder lokal.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
215
Transitionen können einen Event Trigger, eine Guard-Bedingung und eine Aktion in der
Form eventTrigger [Guard-Bedingung] /Aktivität haben.
So erstellen Sie automatisch Operationen von Transitionen aus
Wenn Sie die Schaltfläche "Automatische Erstellung von Operationen in der Zielkomponente
durch Eingabe von Operationsnamen ein-/ausschalten"
aktivieren, wird die entsprechende
Operation in der referenzierten Klasse automatisch erstellt, wenn Sie eine Transition erstellen und
einen Namen,z. B. myOperation() eingeben.
Anmerkung: Operationen können nur dann automatisch erstellt werden, wenn sich der
Zustandsautomat innerhalb einer Klasse oder Schnittstelle befindet.
So erstellen Sie automatisch Operationen von Aktivitäten aus:
1. Klicken Sie mit der rechten Maustaste auf den Zustand und wählen Sie die
entsprechende Aktion/Aktivität aus, z.B. Neu | Eintritt:Aktivität.
2. Geben Sie den Namen der Aktivität ein und stellen Sie sicher, dass Sie am Schluss das
"Klammer auf" und "Klammer zu"-Zeichen "()", also z.B. Eintritt / OnEntryCooler()
eingeben.
© 2016 Altova GmbH
Altova UModel 2017
216
UML-Diagramme
Verhaltensdiagramme
Das neue Element wird auch in der Modell-Struktur angezeigt.
Wenn Sie einen Bildlauf nach unten durch die Modell-Struktur durchführen, sehen Sie,
dass die Operation OnEntryCooler zur übergeordneten Klasse AirConditionController
hinzugefügt wurde.
Bitte beachten Sie:
Operationen werden automatisch für: Do:Aktivität, Eintritt:Aktivität, Austritt:Aktivität sowie
als Guard-Bedingungsaktivitäten und Auswirkungen (in Transitionen) hinzugefügt.
So erstellen Sie einen Transition Trigger:
1. Rechtsklicken Sie auf eine zuvor erstelle Transition (Pfeil).
2. Wählen Sie Neu | Trigger.
Über dem Transition-Pfeil wird in der Transition-Bezeichnung der Buchstabe "a"
angezeigt, falls es sich um den ersten Trigger im Zustandsdiagramm handelt. Den
Triggern werden Standardwerte in der Form: Buchstabe des Alphabets, Ausgangszustand
-> Zielzustand zugewiesen.
3. Doppelklicken Sie auf den neuen Buchstaben und geben Sie die Eigenschaften der
Transition in der Form eventTrigger [Guard-Bedingung] /Aktivität ein.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
217
Syntax der Eigenschaft der Transition: Der Text vor der eckigen Klammer ist der Trigger,
innerhalb der eckigen Klammer befindet sich die Guard-Bedingung und hinter dem
Schrägstrich folgt die Aktivität. Bei Bearbeitung des Strings werden automatisch die
entsprechenden Elemente in der Modell-Struktur erstellt bzw. gelöscht.
Bitte beachten Sie:
Um die Eigenschaften der einzelnen Transition zu sehen, rechtsklicken Sie auf die
Transition (also auf den Pfeil) und wählen Sie die Option "In Modell-Struktur auswählen".
Das Ereignis, die Aktivität und die Einschränkungselemente werden alle unterhalb der
ausgewählten Transition angezeigt.
Hinzufügen eines Aktivitätsdiagramms zu einer Transition:
UModel bietet die einzigartige Möglichkeit, zur näheren Beschreibung der Transition ein
Aktivitätsdiagramm zu einer Transition hinzuzufügen.
1. Rechtsklicken Sie auf einen Transitionspfeil im Diagramm und wählen Sie Neu |
Aktivitätsdiagramm.
Daraufhin wird an der Position des Transitionspfeils ein Aktivitätsdiagrammfenster in das
Diagramm eingefügt.
2. Klicken Sie auf das eingefügte Fenster, um es aktiv zu machen. Über die Bildlaufleisten
können Sie durch das Fenster scrollen.
3. Doppelklicken Sie auf das Aktionsfenster um in das Aktivitätsdiagramm zu wechseln und
die Transition näher zu definieren, z.B. um den Namen der Aktion in "Database logon" zu
ändern.
© 2016 Altova GmbH
Altova UModel 2017
218
UML-Diagramme
Verhaltensdiagramme
Beachten Sie, dass ein neues Aktivitätsdiagrammregister zum Projekt hinzugefügt wurde.
Sie können jedes beliebige Aktivitätsdiagramm-Modellelement zum Diagramm
hinzufügen. Nähere Informationen dazu finden Sie unter "Aktivitätsdiagramm".
4. Klicken Sie auf das Zustandsdiagrammregister um zurückzuwechseln und die
aktualisierte Transition zu sehen.
5. Ziehen Sie gegebenenfalls das Aktivitätsfenster an die gewünschte Stelle im Diagramm
und klicken Sie auf den Ziehpunkt zur Größenanpassung.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
219
Wenn Sie das Aktivitätsfenster zwischen die beiden Zustände ziehen, wird die Transition
in die Aktivität und aus der Aktivität heraus angezeigt.
Zusammengesetzte Zustände
Zusammengesetzter Zustand
Diese Art von Zustand enthält einen zweiten Bereich bestehend aus einer einzigen Region.
Innerhalb dieser Region können beliebig viele Zustände platziert werden.
So fügen Sie eine Region zu einem zusammengesetzten Zustand hinzu:
1. Rechtsklicken Sie auf den zusammengesetzten Zustand und wählen Sie im Kontextmenü
den Befehl Neu | Region.
Daraufhin wird eine neue Region zum Zustand hinzugefügt. Regionen werden durch
strichlierte Linien voneinander getrennt.
So löschen Sie eine Region:
1. Klicken Sie auf die gewünschte Region im zusammengesetzten Zustand und drücken Sie
die Entf-Taste.
Wenn Sie eine Region eines orthogonalen Zustands löschen, so wird dieser wieder zu
einem zusammengesetzten Zustand; sobald die letzte Region eines zusammengesetzten
Zustands gelöscht wurde, wird dieser wieder zu einem einfachen Zustand.
© 2016 Altova GmbH
Altova UModel 2017
220
UML-Diagramme
Verhaltensdiagramme
So platzieren Sie einen Zustand in einen zusammengesetzten Zustand:
1. Klicken Sie auf das gewünschte Zustandselement (z.B. Logging in User) und ziehen Sie
es in den Regionsbereich des zusammengesetzten Zustands.
Der Regionsbereich erscheint markiert, sobald Sie die Maustaste loslassen können. Das
eingefügte Element ist nun Teil der Region und wird im Fenster "Modell-Struktur" als
Child-Element der Region angezeigt.
Wenn Sie den zusammengesetzten Zustand verschieben, werden alle darin enthaltenen
Zustände mitverschoben.
Orthogonaler Zustand
Diese Art von Zustand enthält einen zweiten Bereich bestehend aus zwei oder mehr Regionen,
wobei die einzelnen Regionen auf Gleichzeitigkeit hinweisen.
Wenn Sie mit der rechten Maustaste auf einen Zustand klicken und Neu | Region auswählen,
können Sie neue Regionen hinzufügen.
So blenden Sie Regionsnamen ein/aus:
Klicken Sie auf das Register "Stile", scrollen Sie zum Eintrag "Regionsnamen in
Zustandselementen anzeigen" und wählen Sie true/false aus.
Unterautomatenzustand
Dieser Zustand dient zum Ausblenden der Einzelheiten eines Zustandsautomaten. Dieser Zustand
hat keine Regionen, sondern ist mit einem separaten Zustandsautomaten verknüpft.
So definieren Sie einen Unterautomatenzustand:
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
221
1. Wählen Sie zuerst einen Zustand aus und klicken Sie auf dem Register "Eigenschaften"
auf die Auswahlliste Unterautomatenzustand.
Es erscheint eine Liste mit den derzeit definierten Zustandsautomaten.
2. Wählen Sie den Zustandsautomaten aus, den dieser Unterautomat referenzieren soll.
Beachten Sie bitte: Im Unterautomat wird automatisch ein Hyperlink angezeigt. Wenn Sie
darauf klicken, wird der referenzierte Zustandsautomat, in diesem Fall BankServer,
geöffnet.
So fügen Sie Eintritts- / Austrittspunkte zu einem Unterautomatenzustand hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst einen Unterautomatenzustand
(sichtbar auf dem Register "Eigenschaften") referenzieren.
Dieser Unterautomat muss einen oder mehrere Eintritts- und Austrittspunkte enthalten
1. Klicken Sie in der Titelleiste auf das Symbol Verbindungspunktreferenz
und
klicken Sie anschließend auf den Unterautomatenzustand, zu dem Sie den Eintritts- /
Austrittspunkt hinzufügen möchten.
2. Rechtsklicken Sie auf das Register "Eigenschaften" und wählen Sie den Befehl "Eintritt
hinzufügen". Bitte beachten Sie, dass es an einer anderen Stelle im Diagramm einen
weiteren Eintritts- oder Austrittspunkt geben muss, damit dieses Popup-Menü aktiviert
wird.
© 2016 Altova GmbH
Altova UModel 2017
222
UML-Diagramme
Verhaltensdiagramme
Daraufhin wird eine Eintrittspunktzeile zum Register "Eigenschaften" hinzugefügt und das
Aussehen des Verbindungspunktreferenz-Elements ändert sich.
3. Fügen Sie auf dieselbe Weise einen Austrittspunkt hinzu. Wählen Sie dazu im
Kontextmenü den Befehl "Austritt hinzufügen".
Codegenerierung anhand von Zustandsdiagrammen
Sie können in UModel nun ausführbaren Code (Java, VB.NET oder C#) anhand von
Zustandsdiagrammen generieren. Es werden beinahe alle Zustandsdiagrammelemente und funktionen unterstützt:
Zustand
Zusammengesetzter Zustand, mit jeder hierarchischen Ebene
Orthogonaler Zustand, mit beliebig vielen Regionen
Region
Anfangszustand
Endzustand
Transition
Guard
Trigger
Aufrufereignis
Gabelung
Vereinigung
Entscheidung
Kreuzung
DeepHistory
ShallowHistory
Eintritts-/Austritts-/Do-Aktion
Effekt
Die Generierung von Zustandsautomatencode ist in das normale Round Trip Engineering integriert,
d.h. der Zustandsautomatencode kann bei jedem Forward Engineering automatisch aktualisiert
werden.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
223
In der Abbildung oben sehen Sie das Zustandsdiagramm AirCondition aus dem Verzeichnis ..
\StateMachineCodeGeneration unter...\UModelExamples. Für jede der Sprachen, in der in
UModel Code generiert werden kann, gibt es ein eigenes Verzeichnis, d.h.C#, Java und VB.
Jedes Verzeichnis enthält jeweils einen Ordner AirCondition und einen Ordner Complex, die
jeweils das entsprechende UModel-Projekt, die Programmiersprachen-Projektdateien sowie die
generierten Quelldateien enthalten. Die Projektdatei Complex.ump enthält beinahe alle der von
UModel beim Generieren von Zustandsdiagrammcode unterstützten Modellierungselemente und
Funktionalitäten.
Außerdem enthält jedes Verzeichnis eine Testapplikation, z.B. TestSTMAirCondition.sln für C#,
sodass Sie mit den generierten Quellcodedateien sofort arbeiten können.
© 2016 Altova GmbH
Altova UModel 2017
224
UML-Diagramme
Verhaltensdiagramme
So generieren Sie anhand eines Zustandsdiagramms Code:
Klicken Sie mit der rechten Maustaste in das Zustandsdiagramm und wählen Sie den
Befehl "Zustandsautomatencode generieren" oder
Wählen Sie die Menüoption Projekt | Zustandsautomatencode generieren.
In der Abbildung oben sehen Sie die Standardeinstellungen. Klicken Sie zur
Codegenerierung auf OK.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
225
Der Zustandsautomatencode wird automatisch aktualisiert, wenn Sie das Forward Engineering
starten. Sie können diese Einstellung allerdings ändern, indem Sie auf den Hintergrund des
Zustandsdiagramms klicken und das Kontrollkästchen "Code automatisch aktualisieren"
deaktivieren.
Am generierten Code sollten keine manuellen Änderungen vorgenommen werden, da diese
Änderungen beim Reverse Engineering nicht im Zustandsdiagramm übernommen werden.
Wenn Sie neben dem Feld "Code automatisch aktualisieren" auf das Symbol
Dialogfeld "Zustandsautomatencode generieren" geöffnet, wo Sie die
Codegenerierungseinstellungen ändern können.
klicken, wird das
Bitte beachten Sie:
Um in einem Zustandsdiagramm eine Syntaxüberprüfung durchzuführen, klicken Sie mit
der rechten Maustaste auf das Diagramm und wählen Sie den Befehl
Zustandsautomatensyntax überprüfen.
Arbeiten mit Zustandsdiagrammcode
Die übergeordnete Klasse des Zustandsdiagramms (d.h. die "Controller-Klasse" oder
"Kontextklasse") bildet die einzige Schnittstelle zwischen dem Benutzer des Zustandsdiagramms
und der Zustandsdiagrammimplementierung.
Die Controller-Klasse bietet Methoden, mit Hilfe derer die Zustandsdiagramme von "außen" her
geändert werden können (z.B. nachdem externe Ereignisse eingetreten sind).
Bei der Implementierung des Zustandsdiagramms werden dagegen Controller-Klassenmethoden
("Callbacks") aufgerufen, um den Benutzer des Zustandsdiagramms über Zustandsänderungen
(OnEntry, OnExit, ...), Transitionseffekte und die Möglichkeit Methoden für Bedingungen (Guards)
außer Kraft zu setzen und zu implementieren, zu informieren.
UModel kann einfache Operationen (ohne Parameter) für Entry/Exit/Do-Verhalten,
Transitionseffekte, ...automatisch erstellen, wenn die entsprechende Option aktiviert ist. (siehe
auch Erstellen von Zuständen, Aktivitäten und Transitionen). Diese Methoden können in UModel
beliebig (durch Hinzufügen von Parametern, Definieren der Parameter als abstrakt, usw.) geändert
werden.
Ein Zustandsdiagramm (d.h. seine Controller-Klasse) kann mehrmals instantiiert werden. Alle
Instanzen sind unabhängig voneinander.
Die Ausführung des UML-Zustandsdiagramms ist für das Modell: Bis zur Fertigstellungen
ausführen" konzipiert.
UML-Zustandsautomaten gehen davon aus, dass jedes Ereignis abgeschlossen ist, bevor
© 2016 Altova GmbH
Altova UModel 2017
226
UML-Diagramme
Verhaltensdiagramme
das nächste verarbeitet wird.
Dies bedeutet auch, dass keine Entry/Exit/Do-Aktion oder kein Transitionseffekt eine
neue Transition/eine Zustandsänderung direkt auslösen darf.
Initialisierung
Jede Region eines Zustandsdiagramms muss einen Anfangszustand haben.
Der von UModel generierte Code initialisiert alle Regionen des Zustandsdiagramms
automatisch (oder bei Aufruf der Initialize()-Methode der Controller-Klasse).
Wenn OnEntry-Ereignisse bei der Initialisierung nicht erwünscht sind, können Sie die
Initialize()-Methode manuell aufrufen und OnEntry-Ereignisse beim Start ignorieren.
Abrufen des/der aktuellen Zustands/Zustände
UModel unterstützt sowohl zusammengesetzte Zustände als auch orthogonale Zustände, d.h. es
gibt nicht nur einen aktuellen Zustand, sondern jede Region (auf jeder hierarchischen Ebene) kann
einen aktuellen Zustand haben.
Im Beispiel "AirCondition" wird gezeigt, wie die Regionen des aktuellen Zustands / der aktuellen
Zustände durchlaufen werden.
TreeNode rootNode = m_CurrentStateTree.Nodes.Add(m_STM.getRootState().getName());
UpdateCurrentStateTree(m_STM.getRootState(), rootNode);
private void UpdateCurrentStateTree(AirCondition.AirConditionController.IState
state, TreeNode node)
{
foreach (AirCondition.AirConditionController.IRegion r in state.getRegions())
{
TreeNode childNode = node.Nodes.Add(r.getName() + " : " +
r.getCurrentState().getName());
UpdateCurrentStateTree(r.getCurrentState(), childNode);
}
}
Beispiel 1 - eine einfache Transition
Die entsprechende Operation wird in UModel automatisch generiert.
Generierte Methode im Code:
private class CTestStateMachine : IState
{
…
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
}
Verhaltensdiagramme
227
public bool MyEvent1()
{
…
}
Der Benutzer des Zustandsdiagramms sollte die generierte Methode "MyEvent1" aufrufen,
wenn das entsprechende Ereignis (außerhalb des Zustandsautomaten) eintritt.
Der Rückgabeparameter dieser Ereignismethoden liefert Informationen, ob das Ereignis
eine Zustandsänderung verursacht hat (d.h. ob es eine Auswirkung auf das
Zustandsdiagramm hat) oder nicht. Wenn sich der Automat z.B. im "State1" befindet und
"MyEvent1()" eintritt, so ändert sich der aktuelle Status in "State2" und "MyEvent1()" gibt
"true" zurück. Wenn "State2" aktiv ist und "MyEvent1()" eintritt, ändert sich nichts am
Zustandsdiagramm und MyEvent1() gibt "false" zurück.
Beispiel 2 - eine einfache Transition mit einem Effekt
{
…
// Override to handle entry/exit/do actions, transition effects,...:
public virtual void OnState1State2Effect() {}
}
"OnState1State2Effect()" wird immer dann von der Zustandsdiagrammimplementierung
aufgerufen, wenn die Transition zwischen "State1" und "State2" ausgelöst wird.
Als Reaktion auf diesen Effekt sollte "OnState1State2Effect()" in einer abgeleiteten
Klasse von "CTestStateMachine" außer Kraft gesetzt werden.
"CTestStateMachine:: OnState1State2Effect()" kann auch auf "abstract" gesetzt werden
und Sie erhalten Kompilierfehler bis die Methode außer Kraft gesetzt wird.
Wenn "OnState1State2Effect()" nicht "abstract" ist und die Option "Debug-Meldungen
generieren" aktiv ist, generiert UModel die folgende Debug-Ausgabe:
© 2016 Altova GmbH
Altova UModel 2017
228
UML-Diagramme
Verhaltensdiagramme
// Override to handle entry/exit/do actions, transition
effects,...:
public virtual void OnState1State2Effect()
{OnDebugMessage("ACTION: OnState1State2Effect");}
Beispiel 3 - eine einfache Transition mit einem Effekt-Parameter
{
…
// Additional defined operations of the controller class:
public virtual void OnState1State2Effect(String text)
{
}
}
Zur Durchführung von (automatisch mit UModel erzeugten) Operationen können
Parameter manuell hinzugefügt werden (UModel kann nicht wissen, welcher Typ benötigt
wird).
In diesem Beispiel wurde der Parameter "text:String" zur Effekt-Methode in TestController
hinzugefügt. Beim Aufruf dieser Methode muss ein ordnungsgemäßes Argument definiert
werden (hier: "1 => 2").
Eine andere Möglichkeit wäre z.B. die folgende: Aufruf von statischen Methoden
("MyStatic.OnState1State2Effect("1 => 2")") oder Methoden von Singletons
("getSingleton().OnState1State2Effect("1 => 2")").
Beispiel 4 - entry/exit/do-Aktionen:
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
229
Die entsprechenden Operationen werden in UModel automatisch generiert.
{
…
// Override to handle entry/exit/do actions, transition effects,...:
public virtual void OnExitState3() {}
public virtual void OnEntryState4() {}
public virtual void OnDoState4() {}
}
Zustände können entry/exit/do-Verhalten aufweisen. UModel generiert automatisch die
entsprechenden Operationen zu deren Behandlung.
Wenn im Beispiel oben "MyEvent2()" eintritt, ruft die Zustandsdiagrammimplementierung
"OnExitState3()" auf. Wenn "MyEvent2" einen Effekt hätte, würde dieser in der Folge
aufgerufen werden. Anschließend würden "OnEntryState4" und "OnDoState4" aufgerufen
werden.
Normalerweise sollten diese Methoden außer Kraft gesetzt werden. Wenn sie nicht
abstrakt sind und die Option "Debug-Meldungen generieren" aktiv ist, liefert UModel eine
Standard-Debug-Ausgabe, wie in Beispiel 2 beschrieben.
Diese Methoden können auch Parameter haben, wie in Beispiel 3 gezeigt.
Beispiel 5 - Guards
Transitionen können Guards (Wächterausdrücke) haben, die ermitteln, ob die Transition wirklich
ausgelöst werden kann.
© 2016 Altova GmbH
Altova UModel 2017
230
UML-Diagramme
Verhaltensdiagramme
{
…
// Additional defined operations of the controller class:
public virtual bool CanGoState6()
{
return true; // Override!
}
}
Wenn "State5" der aktive Zustand ist und "MyEvent2" eintritt, so ruft die
Zustandsdiagrammimplementierung "CanGoState6" auf und je nach Ergebnis wird die
Transition ausgelöst oder nicht.
Normalerweise sollten diese Methoden außer Kraft gesetzt werden. Wenn sie nicht
abstrakt sind und die Option "Debug-Meldungen generieren" aktiv ist, liefert UModel eine
Standard-Debug-Ausgabe, wie in Beispiel 2 beschrieben.
Diese Methoden können auch Parameter haben, wie in Beispiel 3 gezeigt.
Es sind mehrere Transitionen mit demselben Ereignis aber unterschiedlichen Guards
möglich. Die Reihenfolge, in der die verschiedenen Guards abgefragt werden, ist nicht
definiert. Wenn eine Transition keinen Guard hat oder der Guard "else" ist, wird sie als
der letzte Guard betrachtet (d.h. dieser Guard wird nur dann ausgelöst, wenn alle anderen
Transitions-Guards "false" zurückgeben). So ist z.B. im Diagramm unten nicht definiert,
ob CanGoState6() oder CanGoState7() zuerst aufgerufen wird. Die dritte Transition wird
nur ausgelöst, wenn CanGoState6() und CanGoState7() false zurückgeben.
Weitere Konstrukte und Funktionalitäten finden Sie in den Beispielen AirCondition.ump und
Complex.ump.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
231
Zustandsdiagramm-Elemente
Startzustand (Pseudozustand)
Der Beginn eines Prozesses.
Endzustand
Das Ende der Abfolge von Prozessen.
Eintrittspunkt (Pseudozustand)
Der Eintrittspunkt eines Zustandsautomaten oder eines zusammengesetzten Zustands.
Austrittspunkt (Pseudozustand)
Der Austrittspunkt eines Zustandsautomaten oder eines zusammengesetzten Zustands.
Entscheidung
Dieses Element stellt eine dynamische bedingte Verzweigung dar, wobei einander gegenseitig
ausschließende Guard Trigger ausgewertet werden (OR Operation).
Kreuzung (Pseudozustand)
Dieses Element stellt das Ende der OR-Operation dar, die durch das Element "Entscheidung"
definiert ist.
Beendung (Pseudozustand)
Das Anhalten der Ausführung des Zustandsautomaten.
Gabelung (Pseudozustand)
Fügt eine vertikale Gabelungsleiste ein.
Dient zum Aufteilen von Sequenzen in nebenläufige Untersequenzen.
Gabelung horizontal (Pseudozustand)
Fügt eine horizontale Gabelungsleiste ein.
Vereinigung (Pseudozustand)
Vereinigt/führt zuvor definierte Untersequenzen zusammen. Alle Aktivitäten müssen
abgeschlossen sein, bevor Sie fortfahren können.
Vereinigung, horizontal (Pseudozustand)
DeepHistory
Ein Pseudozustand, der den zuvor aktiven Zustand in einem zusammengesetzten Zustand
© 2016 Altova GmbH
Altova UModel 2017
232
UML-Diagramme
Verhaltensdiagramme
wiederherstellt.
ShallowHistory
Ein Pseudozustand, der den Ausgangszustand eines zusammengesetzten Zustands
wiederherstellt.
Alle Pseudozustandselemente können in einen anderen "Typ" geändert werden, indem Sie auf
dem Register "Eigenschaften" den Eintrag in der Auswahlliste "Art" ändern.
Verbindungspunktreferenz
Eine Verbindungspunktreferenz stellt eine Verwendung (als Teil eines Unterautomatenzustands)
eines Eintritts-/Austrittspunkts dar, der in der Zustandsautomatenreferenz durch den
Unterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst einen
Unterautomatenzustand referenzieren. (sichtbar auf dem Register "Eigenschaften").
Dieser Unterautomat muss einen oder mehrere Eintritts- oder Austrittspunkte enthalten.
Transition
Eine direkte Beziehung zwischen zwei Zuständen. Ein Objekt im ersten Zustand führt eine oder
mehrere Aktionen durch und tritt anschließend abhängig von einem Ereignis und der Erfüllung
etwaiger Guard-Bedingungen in den zweiten Zustand ein.
Transitionen haben einen Event-Trigger, (eine) Guard-Bedingung(en), eine Aktion (Verhalten) und
einen Zielzustand.
Unterstützte Ereignisunterelemente sind:
ReceiveSignalEvent, SignalEvent, SendSignalEvent, ReceiveOperationEvent,
SendOperationEvent und ChangeEvent.
Automatische Erstellung von Operationen in der Zielkomponente durch Eingabe von
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
233
Operationsnamen ein-/ausschalten
durch Eingabe von Operationsnamen ein-/ausschalten" aktivieren, wird die entsprechende
einen Namen myOperation() eingeben.
© 2016 Altova GmbH
Altova UModel 2017
234
UML-Diagramme
9.1.3
Protokoll-Zustandsautomat
Altova Website:
Verhaltensdiagramme
UML-Protokoll-Zustandsdiagramme
Mit Hilfe von Protokoll-Zustandsautomaten wird eine Sequenz von Ereignissen dargestellt, auf die
ein Objekt reagiert, ohne dass das spezifische Verhalten dargestellt werden muss. In diesem
Diagramm werden die benötigte Ereignissequenz und die resultierenden Änderungen am Zustand
des Objekts modelliert.
Meist dienen Protokoll-Zustandsautomaten zur Beschreibung komplexer Protokolle, z.B. zur
Beschreibung des Datenbankzugriffs über eine bestimmte Schnittstelle oder von
Kommunikationsprotokollen wie TCP/IP.
Protokoll-Zustandsautomaten werden auf dieselbe Weise wie Zustandsdiagramme erstellt, haben
aber weniger Modellierungselemente. Die Protokoll-Übergänge zwischen Zuständen können Vorund Nachbedingungen haben, die definieren, was zutreffen, also "true" sein muss, damit der
Übergang in einen anderen Zustand erfolgen kann, oder was der resultierende Zustand nach dem
Übergang sein muss.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
235
Einfügen von Protokoll-Zustandsdiagramm-Elementen
Einfügen über die Symbole der Symbolleiste:
1. Klicken Sie in der Symbolleiste auf das Symbol "Protokoll-Zustandsautomat".
2. Klicken Sie in das Protokoll-Zustandsdiagramm, um das Element einzufügen. Um
mehrere Elemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste
gedrückt und klicken Sie in das Diagrammfenster.
Ziehen von bestehenden Elementen in das Protokoll-Zustandsdiagramm:
Die meisten Elemente, die in anderen Protokoll-Zustandsdiagrammen vorkommen, können in ein
bestehendes Diagramm eingefügt werden.
Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Protokoll-Zustandsdiagramm.
So fügen Sie einen einfachen Zustand ein:
1. Klicken Sie in der Symbolleiste auf das Zustandssymbol
und anschließend in das
Protokoll-Zustandsdiagramm, um es einzufügen.
2. Geben Sie den Namen des Zustands ein und drücken Sie zur Bestätigung die
Eingabetaste.
Einfache Zustände haben keine Regionen oder andere Arten von Substrukturen.
So erstellen Sie eine Protokoll-Transition zwischen zwei Zuständen:
1. Klicken Sie auf den Transition-Ziehpunkt des Ausgangszustands (auf der rechten Seite
des Elements) oder klicken Sie in der Symbolleiste auf die Schaltfläche "Protocol
Transition".
2. Ziehen Sie den Transition-Pfeil mit der Maus auf den Ziel-Zustand.
Der Textcursor ist automatisch so eingestellt, dass Sie die Vor- und/oder Nachbedingung
eingeben können. Verwenden Sie unbedingt die eckigen Klammern [] und den
Schrägstrich, wenn Sie die Bedingungen direkt eingeben.
Wenn Sie die Vor-/Nachbedingung im Fenster "Eigenschaften" eingeben, werden die
eckigen Klammern und der Schrägstrich automatisch in das Diagramm eingefügt.
© 2016 Altova GmbH
Altova UModel 2017
236
UML-Diagramme
Verhaltensdiagramme
So erstellen Sie Elemente zusammengesetzter Zustände und Unterautomatenzustände
bzw. fügen diese ein:
Siehe Zusammengesetzte Zustände
Protokoll-Zustandsdiagramm-Elemente
Zustand
Ein einfaches Zustandselement mit nur einem Bereich.
Diese Art von Zustand enthält einen zweiten Bereich bestehend aus einer einzigen Region.
Innerhalb dieser Region können beliebig viele Zustände platziert werden.
Diese Art von Zustand enthält einen zweiten Bereich bestehend aus zwei oder mehreren
Regionen, wobei separate Regionen Gleichzeitigkeit kennzeichnen.
Wenn Sie mit der rechten Maustaste auf einen Zustand klicken und den Befehl Neu | Region
auswählen, können Sie neue Regionen hinzufügen.
Mit Hilfe dieses Zustands können Sie die Einzelheiten eines Zustandsautomaten ausblenden.
Dieser Zustand hat keine Regionen, ist aber mit einem separaten Zustandsautomaten verknüpft.
Startzustand (Pseudozustand)
Der Beginn eines Prozesses.
Endzustand
Das Ende der Abfolge von Prozessen.
Eintrittspunkt (Pseudozustand)
Der Eintrittspunkt eines Zustandsautomaten oder eines zusammengesetzten Zustands.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
237
Austrittspunkt (Pseudozustand)
Der Austrittspunkt eines Zustandsautomaten oder eines zusammengesetzten Zustands.
Entscheidung
Dieses Element stellt eine dynamische bedingte Verzweigung dar, wobei einander gegenseitig
ausschließende Guard Trigger ausgewertet werden (OR Operation).
Kreuzung (Pseudozustand)
Dieses Element stellt das Ende der OR-Operation dar, die durch das Element "Entscheidung"
definiert ist.
Beendung (Pseudozustand)
Das Anhalten der Ausführung des Zustandsautomaten.
Gabelung (Pseudozustand)
Fügt eine vertikale Gabelungsleiste ein.
Gabelung horizontal (Pseudozustand)
Fügt eine horizontale Gabelungsleiste ein.
Dient zum Aufteilen von Sequenzen in nebenläufige Untersequenzen
Vereinigung (Pseudozustand)
Vereinigung, horizontal (Pseudozustand)
Eine Verbindungspunktreferenz stellt eine Verwendung (als Teil eines Unterautomatenzustands)
eines Eintritts-/Austrittspunkts dar, der in der Zustandsautomatenreferenz durch den
Unterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst einen
Unterautomatenzustand referenzieren. (sichtbar auf dem Register "Eigenschaften").
Dieser Unterautomat muss einen oder mehrere Eintritts- oder Austrittspunkte enthalten.
Protocol Transition
Eine direkte Beziehung zwischen zwei Zuständen. Ein Objekt im ersten Zustand führt eine oder
© 2016 Altova GmbH
Altova UModel 2017
238
UML-Diagramme
Verhaltensdiagramme
mehrere Aktionen durch und tritt anschließend abhängig von einem Ereignis und der Erfüllung
etwaiger Vor- oder Nachbedingungen in den zweiten Zustand ein.
Nähere Informationen dazu finden Sie unter Einfügen von Protokoll-Zustandselementen.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.1.4
Verhaltensdiagramme
239
Use Case-Diagramm
Eine Anleitung zum Hinzufügen von Klassen zum Diagramm finden Sie im Tutorial im Abschnitt
Use Cases.
© 2016 Altova GmbH
Altova UModel 2017
240
UML-Diagramme
9.1.5
Altova Website:
Verhaltensdiagramme
UML-Kommunikationsdiagramme
In Kommunikationsdiagrammen werden Interaktionen d.h. Nachrichtenflüsse zwischen Objekten
zur Laufzeit und die Beziehungen zwischen den miteinander in Wechselbeziehung stehenden
Objekten dargestellt. Im Grunde dienen diese Diagramme zum Modellieren des dynamischen
Verhaltens von Anwendungsfällen (Use Cases).
Kommunikationsdiagramme weisen denselben Aufbau wie Sequenzdiagramme auf, mit
Ausnahme dessen, dass die Notation ein anderes Layout aufweist. Zur Kennzeichnung der
Reihenfolge der Nachrichten und der Schachtelung sind die Nachrichten nummeriert.
Sie können in UModel mit einer einzigen einfachen Aktion Kommunikationsdiagramme anhand
von Sequenzdiagrammen erstellen und umgekehrt. Nähere Informationen dazu finden Sie unter
"Generieren von Sequenzdiagrammen".
Einfügen von Kommunikationsdiagrammelementen
Verwendung der Symbolleisten-Schaltflächen:
1. Klicken Sie in der Kommunikationsdiagramm-Symbolleiste auf das entsprechende
Kommunikationssymbol.
2. Klicken Sie in das Kommunikationsdiagramm, um das Element einzufügen. Um mehrere
Ziehen vorhandener Elemente in das Kommunikationsdiagramm:
Elemente, die in anderen Diagrammen vorkommen, z.B. Klassen, können in ein
Kommunikationsdiagramm eingefügt werden.
Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Kommunikationsdiagramm.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
241
Lebenslinie
Das Element "Lebenslinie" ist Teil einer Interaktion mehrerer Elemente. Sie haben in UModel die
Möglichkeit auch andere Elemente in das Kommunikationsdiagramm einzufügen, z.B. Klassen.
Jedes dieser Elemente wird als neue Lebenslinie angezeigt. Sie können die Farben/Schattierung
der Lebenslinie über die "Farbverlauf Titel"-Auswahllisten auf dem Register "Stile" neu definieren.
Zur Erstellung einer Lebenslinie mit mehreren Zeilen, drücken Sie Strg + Eingabetaste, um
eine neue Zeile zu erstellen.
So fügen Sie eine Kommunikationslebenslinie ein:
1. Klicken Sie in der Titelleiste auf das Symbol "Lebenslinie" und anschließend auf das
Kommunikationsdiagramm, um sie einzufügen.
2. Geben Sie einen Namen für die Lebenslinie ein, um den Standardnamen "Lebenslinie1"
bei Bedarf zu ändern.
Nachrichten
Eine Nachricht ist ein Modellierungselement, das eine bestimmte Art von Kommunikation in einer
Interaktion definiert. Bei einer Kommunikation kann es sich z.B. um das Auslösen eines Signals,
den Aufruf einer Operation, das Erstellen oder Löschen einer Instanz handeln. Die Nachricht
definiert den Absender und Empfänger und um welche Art von Kommunikation es sich handelt.
Nachricht (Aufruf)
(Löschung)
Nachricht (Antwort)
Nachricht (Erstellung)
Nachricht
So fügen Sie eine Nachricht ein:
1. Klicken Sie auf das entsprechende Nachrichtensymbol in der Symbolleiste.
2. Ziehen Sie die Nachrichtenlinie auf die empfangenden Objekte.
Die Lebenslinie erscheint markiert, wenn die Nachricht an diese bestimmte Stelle
gezogen werden kann.
© 2016 Altova GmbH
Altova UModel 2017
242
UML-Diagramme
Verhaltensdiagramme
Anmerkung: Wenn Sie die Strg-Taste gedrückt halten, können Sie mit jedem Klick eine
Nachricht einfügen.
So fügen Sie weitere Nachrichten ein:
1. Rechtsklicken Sie auf die vorhandene Kommunikationsverbindung und wählen Sie Neu |
Nachricht.
Die Richtung, in die Sie den Pfeil ziehen, bestimmt die Richtung der Nachricht.
Antwortnachrichten können in jede der beiden Richtungen weisen.
Wenn Sie auf ein Nachrichtensymbol klicken und dabei die Strg-Taste gedrückt halten,
können Sie mehrere Nachrichten einfügen, indem Sie mehrmals ins Diagramm klicken
und die Maus ziehen.
Nachrichtennummerierung
In Kommunikationsdiagrammen wird die Nummerierung in Dezimalschreibweise verwendet,
wodurch die hierarchische Struktur der Nachrichten im Diagramm klarer ersichtlich ist. Bei der
Reihenfolge handelt es sich um eine durch Punkte getrennte Liste von aufeinander folgenden
Zahlen, gefolgt von einem Doppelpunkt und dem Namen der Nachricht.
Kommunikationsdiagrammen:
Sie können in UModel in einer einzigen Aktion Kommunikationsdiagramme anhand von
Sequenzdiagrammen generieren und umgekehrt,
Rechtsklicken Sie an eine beliebige Stelle in einem Kommunikationsdiagramm und wählen Sie
im Kontextmenü den Befehl Sequenzdiagramm generieren.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
© 2016 Altova GmbH
Verhaltensdiagramme
243
Altova UModel 2017
244
UML-Diagramme
9.1.6
Altova Website:
Verhaltensdiagramme
UML-Interaktionsübersichtsdiagramme
Interaktionsübersichtsdiagramme sind eine Variante von Aktivitätsdiagrammen und geben Ihnen
einen Überblick über die Interaktion zwischen anderen Interaktionsdiagrammen wie z.B. Sequenz, Aktivitäts, Kommunikations- oder Zeitverlaufsdiagrammen. Interaktionsübersichtsdiagramme
werden auf ähnliche Art wie Aktivitätsdiagramme und unter Verwendung derselben
Modellierungselemente (Start-/Endpunkte, Gabelungen, Vereinigungen usw.) erstellt.
Anstelle von Aktivitätselementen werden zwei Arten von Interaktionselementen verwendet: Die
Elemente "Interaktion" und "Interaktionsverwendung".
Sequenz-, Kommunikations-, Zeitverlaufs- oder Interaktionsübersichtsdiagramme werden als
Elemente in Form grafischer Symbole innerhalb eines Rahmens dargestellt, in dessen linker
oberer Ecke das Schlüsselwort "SD" angezeigt wird.
Elemente für Interaktionsinstanzen sind Referenzen, die auf vorhandene Interaktionsdiagramme
verweisen, wobei im Titelbereich des Rahmens das Schlüsselwort "Ref" und innerhalb des
Rahmens der Name der Interaktionsinstanz angezeigt wird.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
245
Einfügen von Interaktionsübersichtselementen
1. Klicken Sie in der Interaktionsübersichtsdiagramm-Symbolleiste auf das entsprechende
Symbol
2. Klicken Sie in das Diagramm, um das Element einzufügen. Um mehrere Elemente des
ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt und klicken Sie in
das Diagrammfenster.
Ziehen vorhandener Elemente in das Interaktionsübersichtsdiagramm:
Elemente, die in anderen Diagrammen vorkommen, z.B. Sequenz-, Aktivitäts-, Kommunikationsoder Zeitverlaufsdiagramme, können in ein Interaktionsübersichtsdiagramm eingefügt werden.
Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Diagramm.
Einfügen eines Interaktionselements:
1. Klicken Sie in der Symbolleiste auf das Symbol "Aufrufverhalten-Aktion (Interaktion)"
und anschließend in das Interaktionsübersichtsdiagramm, um es einzufügen.
Wenn Sie die Beispieldatei Bank_Multilanguage.ump aus dem Ordner ...\Examples
verwenden, wird das "Collect Account Information" Sequenzdiagramm automatisch
eingefügt. Standardmäßig wird das erste in der Modell-Struktur gefundene
Sequenzdiagramm ausgewählt.
2. Um ein anderes Interaktionselement auszuwählen, klicken Sie auf dem Register
"Eigenschaften" auf die Auswahlliste Verhalten/Diagramm.
Daraufhin wird eine Liste aller Elemente angezeigt, die eingefügt werden können.
© 2016 Altova GmbH
Altova UModel 2017
246
UML-Diagramme
Verhaltensdiagramme
3. Klicken Sie auf das gewünschte Element, z.B. auf Connect to BankAPI.
Da es sich dabei auch um ein Sequenzdiagramm handelt, wird das Interaktionselement
als Symbol eines Sequenzdiagramms angezeigt.
Bei Auswahl von <ref> BankAPI wird die Instanz des Interaktionselements angezeigt.
Einfügen einer Interaktionselementinstanz:
1. Klicken Sie in der Symbolleiste auf das Symbol "Aufrufverhalten-Aktion
(Interaktionsverwendung)
und anschließend in das Interaktionsübersichtsdiagramm,
um das Element einzufügen.
Wenn Sie die Beispieldatei Bank_Multilanguage.ump aus dem Ordner ...
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
247
\UModelExamples verwenden, wird das "Collect Account Information"
Sequenzdiagramm automatisch als Interaktionselement eingefügt. Standardmäßig wird
das erste in der Modell-Struktur gefundene Sequenzdiagramm ausgewählt
2. Um das Interaktionselement zu ändern, doppelklicken Sie auf dem Register
"Eigenschaften" auf die Auswahlliste Verhalten.
Daraufhin wird eine Liste aller Elemente angezeigt, die eingefügt werden können.
3. Wählen Sie das gewünschte Element aus.
Beachten Sie, dass alle mit dieser Methode eingefügten Elemente wie in der Abbildung
oben angezeigt werden, d.h. mit "ref" im Titelbereich des Rahmens.
Verzweigungsknoten
Fügt einen Verzweigungsknoten mit einer einzigen eingehenden Transition und mehreren mit
Guards versehenen ausgehenden Transitionen ein. Nähere Informationen dazu finden Sie unter
"Erstellen einer Verzweigung".
Verbindungsknoten
Fügt einen Verbindungsknoten ein, der mehrere alternative durch den Verzweigungsknoten
definierte Transitionen zusammenführt. Gleichzeitige Prozesse werden dabei von diesem Knoten
nicht synchronisiert, sondern es wird einer der Prozesse ausgewählt.
Startknoten
Der Anfang eines Aktivitätsprozesses. Eine Interaktion kann mehrere Startknoten haben.
Das Ende des Interaktionsprozesses. Eine Interaktion kann mehrere Endknoten haben. Alle
Flüsse werden gestoppt, wenn der "erste" Endknoten erreicht wird.
Dient zum Teilen von Flüssen in mehrere parallele Flüsse.
Dient zum Teilen von Flüssen in mehrere parallele Flüsse.
© 2016 Altova GmbH
Altova UModel 2017
248
UML-Diagramme
Verhaltensdiagramme
Fügt einen vertikalen Synchronisationsknoten ein.
Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknoten definierte
Flüsse.
Fügt einen horizontalen Synchronisationsknoten ein.
Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknoten definierte
Flüsse.
Zeitdauerbedingung hinzufügen
Eine Zeitdauer definiert eine Wertespezifikation, die eine Zeitdauer zwischen einem Start- und
einem Endpunkt angibt. Eine Zeitdauer ist oft ein Ausdruck, der die Anzahl der Uhrticks darstellt,
die während dieser Dauer verstreichen.
Kontrollfluss
Ein Kontrollfluss ist eine Kante, d.h. eine mit einem Pfeil versehene Linie, die zwei Verhalten
verbindet und eine Interaktion startet, nachdem die vorherige zu Ende geführt wurde.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.1.7
Verhaltensdiagramme
249
Sequenzdiagramm
Altova Website:
UML-Sequenzdiagramme
UModel unterstützt das in UML definierte Standard-Sequenzdiagramm und ermöglicht die
einfache Manipulation von Objekten in Objekten und Nachrichten zur Modellierung von
Fallszenarios. Beachten Sie bitte, dass die in den folgenden Abschnitten gezeigten
Sequenzdiagramme nur in den Beispieldateien Bank_Java.ump, Bank_CSharp.ump und
Bank_MultiLanguage.ump im UModel-Ordner ...\UModelExamples verfügbar sind.
Bitte beachten Sie: Sie können ein Sequenzdiagramm nun direkt anhand von Quellcode (siehe
Sequenzdiagramm: Diagrammgenerierung) generieren.
© 2016 Altova GmbH
Altova UModel 2017
250
UML-Diagramme
Verhaltensdiagramme
Einfügen von Sequenzdiagrammelementen
In einem Sequenzdiagramm werden dynamische Laufzeit-Objektbeziehungen mit Hilfe von
Nachrichten modelliert. Sequenzdiagramme dienen im Allgemeinen zur Verdeutlichung einzelner
Use Case-Szenarios.
Lebenslinien sind die horizontal angeordneten Kästchen am oberen Rand des
Diagramms. Zusammen mit einer strichlierten vertikalen Linie stellen sie das Objekt und
seine Interaktionen in einem zeitlichen Ablauf dar. Nachrichten werden in Form von
Pfeilen zwischen den Lebenslinien von zwei oder mehr Objekten dargestellt.
Nachrichten werden zwischen sendenden und empfangenden Objekten gesendet und
als Pfeile mit einer Bezeichnung dargestellt. Nachrichten können eine Sequenznummer
und verschiedene weitere optionale Attribute haben: argument list usw. Es werden
bedingte, optionale und alternative Nachrichten unterstützt. Nähere Informationen dazu
finden Sie unter Combined Fragment .
Nähere Informationen finden Sie unter den folgenden Themen:
Lebenslinie
Combined Fragment
Interaction Use
Gate
Zustandsinvariante
Nachrichten
Sequenzdiagramm- und andere UModel-Elemente können auf verschiedene Arten in ein
Sequenzdiagramm eingefügt werden.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
251
Über die Symbolleistensymbole:
1. Klicken Sie in der Sequenzdiagrammsymbolleiste auf das jeweilige
Sequenzdiagrammsymbol.
2. Klicken Sie in das Sequenzdiagramm, um das Element einzufügen. Um mehrere
Ziehen bestehender Elemente in das Sequenzdiagramm:
Die meisten Classifier-Arten sowie Elemente, die in anderen Sequenzdiagrammen vorkommen,
können in ein bestehendes Sequenzdiagramm eingefügt werden.
dazu das Suchfunktionstextfeld verwenden oder Strg + F drücken).
2. Ziehen Sie das Element/die Elemente in das Sequenzdiagramm.
Lebenslinie
Lebenslinie
Eine Lebenslinie ist als einzelnes Element an einer Interaktion beteiligt. Sie haben in UModel die
Möglichkeit auch andere Elemente in das Sequenzdiagramm einzufügen, z.B. Klassen und
Akteure. Jedes dieser Elemente wird als neue Lebenslinie angezeigt, sobald es vom Register
"Modell-Struktur" in das Diagrammfenster gezogen wurde.
Die Bezeichnung der Lebenslinie wird in einer Leiste am oberen Rand des Sequenzdiagramms
angezeigt. Die Beschriftungen können in der Leiste neu positioniert und in der Größe angepasst
© 2016 Altova GmbH
Altova UModel 2017
252
UML-Diagramme
Verhaltensdiagramme
werden, wobei die Änderungen sofort im Diagrammfenster zu sehen sind. Auch die Farben/
Schattierung der Beschriftung lassen sich über die Farbverlaufsauswahllisten für den Titel auf dem
Register "Stile" anpassen.
Zur Erstellung einer Lebenslinie mit mehreren Zeilen, drücken Sie Strg + Eingabetaste, um
eine neue Zeile zu erstellen.
Die meisten Arten von Classifiern können in ein Sequenzdiagramm eingefügt werden. Im Feld
"steht für" auf dem Register "Eigenschaften" wird der Elementtyp angezeigt, der als Lebenslinie
fungiert. Wenn Sie Eigenschaften, deren Typ definiert ist, in ein Sequenzdiagramm ziehen, wird
ebenfalls eine Lebenslinie erstellt.
Ausführungsspezifikation (Objektaktivierung):
Eine Ausführungsspezifikation (Aktivierung) wird in Form eines Kästchens (Rechteck) auf der
Objektlebenslinie dargestellt. Eine Aktivierung ist die Ausführung einer Prozedur und die Zeit, die
benötigt wird, um etwaige geschachtelte Prozeduren auszuführen. Aktivierungskästchen werden
automatisch erstellt, wenn zwischen zwei Lebenslinien eine Nachricht erstellt wird.
Eine rekursive Nachricht oder Selbstnachricht (self message), also eine Nachricht, die eine
andere Methode in derselben Klasse aufruft), erstellt gestapelte Aktivierungskästchen.
Ein-/Ausblenden von Aktivierungskästchen:
1. Klicken Sie auf das Register Stile und scrollen Sie zum unteren Ende der Liste.
Über das Auswahlfeld "Ausführungsspezifikationen anzeigen" können Sie die
Aktivierungskästchen im Sequenzdiagramm ein- und ausblenden.
Lebenslinienattribute:
Über das Kontrollkästchen Löschung können Sie einen Lösch-Marker oder Stopp zur Lebenslinie
hinzufügen, ohne eine Löschnachricht verwenden zu müssen.
Über das Feld Selektor können Sie einen Ausdruck eingeben, der den durch die Lebenslinie
dargestellten Teil spezifiziert, wenn das Element, das verbunden werden kann, mehrere Werte
hat, d.h. eine Multiplizität größer als eins aufweist.
Gehe zu Lebenslinienelement
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
253
Wenn Sie mit der rechten Maustaste auf eine Lebenslinie klicken, können Sie die Option "Gehe
zu XXX" auswählen, wobei XXX für den Typ der speziellen Lebenslinie steht, auf die Sie geklickt
haben. Das Element wird daraufhin im Fenster "Model-Struktur" angezeigt.
Combined Fragment
Combined Fragment
Combined Fragments sind Untereinheiten oder Abschnitte einer Interaktion. Der
Interaktionsoperator, der im Fünfeck in der linken oberen Ecke angezeigt wird, definiert, um
welche spezifische Art von Combined Fragment es sich handelt. Die Einschränkung definiert
daher das jeweilige Fragment z.B. loop fragment, alternative fragment usw., welches in der
Interaktion verwendet wird.
Über die Symbole für Combined Fragments in der Symbolleiste können Sie bestimmte Combined
Fragments einfügen: seq, alt oder loop. Auch durch Klicken auf die InteraktionsoperatorAuswahlliste können Sie das spezifische Interaktionsfragment definieren.
© 2016 Altova GmbH
Altova UModel 2017
254
UML-Diagramme
Verhaltensdiagramme
Interaktionsoperatoren
Lose Ordnung seq
Das Combined Fragment stellt eine lose Ordnung zwischen dem Verhalten der Operanden dar.
Alternativen alt
Nur einer der definierten Operanden wird ausgewählt. Der Operand muss eine "Guard-Expression"
haben, deren Auswertung "true" ergibt.
Wenn in einem der Operanden der Guard-Ausdruck "else" verwendet wird, wird dieser Operand
ausgeführt, wenn alle anderen Guards den Wert "false" zurückgeben. Die Guard-Expression kann
unmittelbar beim Einfügen eingegeben werden und wird innerhalb der beiden eckigen Klammern
angezeigt.
Bei der Interaktionsbedingung handelt es sich eigentlich um den Guard-Ausdruck zwischen
den eckigen Klammern.
Option opt
Option steht für eine Auswahl, wobei entweder nur der Operand ausgeführt wird oder nichts
passiert.
Abbruchfragment break
Der Break-Operator wird ausgewählt, wenn Guard "true" ist. Der Rest des umschließenden
Fragments wird ignoriert.
Parallel par
Zeigt an, dass das Combined Fragment eine parallele Zusammenführung von Operanden darstellt.
Strenge Ordnung strict
Das Combined Fragment stellt eine strenge Ordnung zwischen dem Verhalten der Operanden
dar.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
255
Schleife loop
Der Schleifen-Operand wird so oft wiederholt, wie in der Guard-Expression definiert.
Nachdem Sie diesen Operand ausgewählt haben, können Sie den Ausdruck (im SchleifenFünfeck) direkt bearbeiten, indem Sie darauf doppelklicken.
Kritischer Bereich critical
Das Combined Fragment stellt einen kritischen Bereich dar. Die Sequenz(en) darf/dürfen nicht
durch andere Prozesse unterbrochen werden.
Negativ neg
Definiert, dass das Fragment ungültig ist und dass alle anderen als gültig gelten.
Sicherstellung assert
Kennzeichnet das gültige Combined Fragment und seine Sequenzen. Wird oft in Kombination mit
consider- oder ignore-Operanden verwendet.
Ignore ignore
Definiert, welche Nachricht in der Interaktion ignoriert werden soll. Wird oft im Zusammenhang mit
"Sicherstellung" oder "Consider"-Operanden verwendet.
Consider consider
Definiert, welche Nachricht in der Interaktion berücksichtigt werden soll.
Hinzufügen von Interaktionsoperanden zu einem Combined Fragment:
1. Rechtsklicken Sie auf das Combined Fragment und wählen Sie Neu |
Interaktionsoperand. Der Textcursor wird automatisch so gesetzt, dass Sie die Guard
Condition eingeben können.
2. Geben Sie die Guard Condition für den Interaktionsoperanden ein, z.B. !passwordOK
und bestätigen Sie mit der Eingabetaste.
Mit Strg + Eingabetaste können Sie einen mehrzeiligen Interaktionsoperanden
erstellen.
Fügen Sie nun auf dieselbe Art den zweiten Interaktionsoperanden mit der Guard Condition
"else" ein.
Die einzelnen Operanden im Fragment werden durch strichlierte Linien getrennt.
Löschen von Interaktionsoperanden:
© 2016 Altova GmbH
Altova UModel 2017
256
UML-Diagramme
Verhaltensdiagramme
1. Doppelklicken Sie im Diagramm (nicht auf dem Register "Eigenschaften") auf die GuardExpression im Combined Fragment.
2. Löschen Sie die Guard-Expression zur Gänze und drücken Sie zur Bestätigung die
Eingabetaste.
Die Guard Expression/der Interaktionsoperand wird entfernt und die Größe des Combined
Fragment wird automatisch angepasst.
Interaction Use
Interaction Use
Das Element "Interaction Use" ist eine Referenz auf ein Interaktionselement. Mit Hilfe dieses
Elements können Sie Abschnitte einer Interaktion mit verschiedenen anderen Interaktionen
gemeinsam verwenden.
Wenn Sie auf die Auswahlliste "referenziert" klicken, können Sie die Interaktion auswählen, auf
die Sie referenzieren möchten. Der Name der ausgewählten Interaktion wird im Element
angezeigt.
Bitte beachten Sie:
Sie können auch ein vorhandenes Interaction Use-Element aus der Modell-Struktur ins
Diagrammfenster ziehen.
Gate
Gate
Ein Gate ist ein Verbindungspunkt, über den Nachrichten in und aus Interaktionsfragmente/n
übertragen werden können. Gates werden mittels Nachrichten miteinander verbunden.
1. Fügen Sie das Gate-Element in das Diagramm ein.
2. Erstellen Sie eine neue Nachricht und ziehen Sie den Cursor vom Gate zur Lebenslinie
oder von einer Lebenslinie auf ein Gate.
Dadurch werden die beiden Elemente miteinander verbunden. Das Quadrat, das das Gate
darstellt, wird nun kleiner angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
257
Zustandsinvariante
Zustandsinvariante
Eine Zustandsinvariante ist eine Bedingung oder eine Einschränkung, die auf eine Lebenslinie
angewendet wird. Die Bedingung muss zutreffen, damit die Lebenslinie vorhanden sein kann.
So definieren Sie eine Zustandsinvariante:
1. Klicken Sie auf das Symbol "Zustandsinvariante" und anschließend auf die Lebenslinie
oder auf eine Objektaktivierung, um diese einzufügen.
2. Geben Sie die gewünschte Bedingung/Einschränkung ein, z.B. accountAmount > 0 und
drücken Sie zur Bestätigung die Eingabetaste.
Nachrichten
Nachrichten werden von sendenden an empfangende Lebenslinien gesendet und in Form
beschrifteter Pfeile angezeigt. Nachrichten können eine Sequenznummer und verschiedene
andere optionale Attribute aufweisen: argument list usw. Nachrichten werden von oben nach unten
angezeigt, d.h. die vertikale Linie stellt den zeitlichen Ablauf im Sequenzdiagramm dar.
Ein Aufruf ist eine synchrone oder asynchrone Kommunikation, die eine Operation
aufruft, über die die Kontrolle zum sendenden Objekt zurückkehren kann. Ein Aufrufpfeil
zeigt zum Anfang der Aktivierung, die der Aufruf initiiert.
Rekursionen oder Aufrufe einer anderen Operation desselben Objekts werden durch
Übereinanderstapeln von Aktivierungskästchen angezeigt (Ausführungsspezifikationen).
1. Klicken Sie in der Sequenzdiagramm-Symbolleiste auf das jeweilige Nachrichtensymbol.
2. Klicken Sie auf die Lebenslinie oder das Aktivierungskästchen des Sender-Objekts.
© 2016 Altova GmbH
Altova UModel 2017
258
UML-Diagramme
Verhaltensdiagramme
3. Ziehen Sie die Nachrichtenlinie auf die Lebenslinie oder das Aktivierungskästchen des
Empfängerobjekts. Objektlebenslinien erscheinen markiert, wenn Sie die Nachricht
dorthin ziehen können.
Die Richtung, in die Sie die Pfeile ziehen, bestimmt die Richtung der Nachricht.
Ein oder mehrere Aktivierungskästchen wird bzw. werden automatisch auf den Sender-/
Empfänger-Objekten erstellt oder in der Größe angepasst. Sie können deren Größe auch
manuell durch Ziehen der entsprechenden Ziehpunkte anpassen.
Abhängig davon, welche Einstellungen Sie für die Nummerierung der Nachrichten aktiviert
haben, wird die Nummerierungsreihenfolge aktualisiert.
können Sie mehrere Nachrichten einfügen. Ziehen Sie dazu einfach mehrere Nachrichten
in das Diagrammfenster.
So löschen Sie eine Nachricht:
1. Klicken Sie auf die jeweilige Nachricht, um sie auszuwählen.
2. Drücken Sie die Entf-Taste, um die Nachricht aus dem Modell zu löschen oder
rechtsklicken Sie auf die Nachricht und wählen Sie den Befehl "Aus Diagramm löschen".
Die Nummerierung der Nachrichten und die Aktivierungskästchen der verbleibenden
Objekte werden aktualisiert.
"Gehe zu-Operation" für Call-Nachrichten:
Die durch Call-Nachrichten referenzierten Operationen werden in Sequenz- und
Kommunikationsdiagrammen verwendet.
1. Rechtsklicken Sie auf eine Call-Nachricht und wählen Sie den Option "Gehe zu
Operation".
Die Anzeige ändert sich und die die Verbindungsoperation wird auf dem Register "ModellStruktur" angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
259
Bitte beachten Sie:
Statische Operationsnamen werden in Sequenzdiagrammen unterstrichen angezeigt.
So positionieren Sie zusammengehörige Nachrichten:
1. Klicken Sie auf die entsprechende Nachricht und ziehen Sie sie in vertikaler Richtung, um
sie neu zu positionieren. Standardmäßig werden beim Neupositionieren einer Nachricht
alle mit der aktiven in Zusammenhang stehenden Nachrichten mitverschoben.
Mit Strg + Klick können Sie mehrere Nachrichten auswählen.
So positionieren Sie Nachrichten einzeln:
1. Klicken Sie auf das Symbol "Verschieben zusammengehöriger Nachrichten ein/
aus"
, um diese Funktion zu deaktivieren.
2. Klicken Sie auf die gewünschte Nachricht und ziehen Sie sie, um sie zu verschieben.
Nur die ausgewählte Nachricht wird beim Ziehen verschoben. Sie können die Nachricht an
einer beliebigen Stelle auf der vertikalen Achse zwischen den Objektlebenslinien
positionieren.
So erstellen Sie automatisch Antwortnachrichten:
1. Klicken Sie auf die Schaltfläche "Automatische Erstellung von Antworten auf
Nachrichten (Call) ein/aus"
.
2. Erstellen Sie eine neue Nachricht zwischen den beiden Lebenslinien. Daraufhin wird
automatisch eine Antwortnachricht eingefügt.
Nachrichtennummerierung:
UModel unterstützt verschiedene Methoden der Nachrichtennummerierung: hierarchisch, einfach
und keine.
© 2016 Altova GmbH
Altova UModel 2017
260
UML-Diagramme
Keine
Verhaltensdiagramme
entfernt alle Nachrichtennummern.
Einfach
nummeriert alle Nachrichten von oben nach unten, also in der Reihenfolge,
in der sie auf der Zeitachse vorkommen, durch.
Hierarchisch
verwendet eine Dezimaldarstellung, sodass die hierarchische Struktur
der Nachrichten im Diagramm deutlich wird. Die Hierarchie wird in Form einer durch
Punkte getrennten Nummerierung, gefolgt von einem Doppelpunkt und dem Namen der
Nachricht dargestellt.
So wählen Sie die Art der Nachrichtennummerierung aus:
Es gibt zwei Methoden, um das Nummerierungssystem auszuwählen:
Klicken Sie auf das jeweilige Symbol in der Symbolleiste.
Wählen Sie das Nummerierungssystem über das Register "Stile" aus.
Um das Nummerierungssystem über das Register "Stile" auszuwählen:
1. Klicken Sie auf das Register "Stile" und scrollen Sie hinunter zum Feld
Nachrichtennummern.
2. Klicken Sie auf das Auswahllistenfeld und wählen Sie die gewünschte
Nummerierungsoption aus.
Die gewählte Nummerierungsoption wird sofort im Sequenzdiagramm angezeigt.
Bitte beachten Sie:
Bei Vorhandensein nicht eindeutiger Spuren werden mit dem gewählten
Nummerierungssystem nicht immer alle Nachrichten richtig nummeriert. Fügen Sie in
diesem Fall Antwortnachrichten hinzu, um Unklarheiten zu beseitigen.
Antwortnachrichten:
Zum Erstellen von Antwortnachrichten stehen Nachrichtenantwortsymbole zur Verfügung. Diese
werden als strichlierte Pfeile dargestellt.
Im Allgemeinen geht es außerdem aus dem unteren Bereich der Aktivierungskästchen - falls
diese aktiviert sind - hervor, ob Antwortnachrichten erwartet werden. Wenn Aktivierungskästchen
deaktiviert wurden (Register "Stile" | Show Execution Specifics=false), sollten aus Gründen der
Übersichtlichkeit Pfeile verwendet werden.
Wenn Sie die Schaltfläche "Automatische Erstellung von Antworten auf Nachrichten (Call) ein/
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
261
aus"
aktivieren, wird automatisch eine syntaktisch korrekte Antwortnachricht erstellt, wenn Sie
eine Call-Nachricht zwischen Lebenslinien/Aktivierungskästen erstellen.
Erstellen von Objekten mit Hilfe von Nachrichten:
1. Nachrichten können neue Objekte erstellen. Dies erfolgt über das Symbol "Nachricht
(Erstellung)
.
2. Ziehen Sie den Nachrichtenpfeil zur Lebenslinie eines bestehenden Objekts, um das
Objekt zu erstellen. Diese Nachrichtenart endet in der Mitte eines Objektrechtecks und
positioniert das Objektkästchen oft in vertikaler Richtung neu.
Senden von Nachrichten an bestimmte Klassenmethoden/-operationen in
Sequenzdiagrammen
Nachdem Sie eine Klasse aus der Modellstruktur in ein Sequenzdiagramm eingefügt haben,
können Sie anschließend mit Hilfe der UModel Syntaxhilfe und der Autokomplettierungsfunktionen
eine Nachricht von einer Lebenslinie zu einer bestimmten Methode der Empfängerklasse
(Lebenslinie) erstellen.
1. Erstellen Sie eine Nachricht zwischen zwei Lebenslinien, wobei es sich beim
Empfängerobjekt um eine Klassenlebenslinie (Bank) handeln muss.Nachdem Sie den
Nachrichtenpfeil gezogen haben, erscheint der Name der Nachricht automatisch
markiert.
2. Geben Sie über die Tastatur ein Zeichen ein, z.B. "b". Es erscheint ein Popup-Fenster
mit einer Liste der verfügbaren Klassenmethoden.
3. Wählen Sie eine Operation aus der Liste aus, z.B. collectAccountinfos und drücken Sie
die Eingabetaste.
4. Drücken Sie die Leertaste und anschließend die Eingabetaste, um das automatisch
vorgegebene Klammerzeichen auszuwählen.
© 2016 Altova GmbH
Altova UModel 2017
262
UML-Diagramme
Verhaltensdiagramme
Es erscheint ein Syntaxhilfefenster, über das Sie den Parameter korrekt eingeben
können.
Erstellen von Operationen in referenzierten Klassen
durch Eingabe von Operationsnamen ein-/ausschalten"
aktivieren, wird die entsprechende
einen Namen myOperation() eingeben.
Nachrichtensymbole:
Nachricht (Aufruf)
Nachricht (Antwort)
Nachricht (Löschung)
Asynchrone Nachricht (Aufruf)
Asynchrone Nachricht (Antwort)
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
263
Asynchrone Nachricht (Löschung)
Verschieben zusammengehöriger Nachrichten ein/aus
Automatische Erstellung von Antworten auf Nachrichten (Call) ein/aus
Generieren von Sequenzdiagrammen anhand von Quellcode
Sie können in UModel nun Sequenzdiagramme direkt anhand von Code erstellen. .
Im Beispiel unten sehen Sie, wie man automatisch ein Sequenzdiagramm unter Verwendung
einer bestehenden Methode erstellt. Sie können auf diese Weise natürlich auch anhand Ihres
eigenen Codes ein Sequenzdiagramm erstellen. Die Methode steht im OrgChart-Paket zur
Verfügung, welches im Tutorial mit dem Befehl Projekt | Quellverzeichnis importieren
importiert wurde. Nähere Informationen zum Importieren von Code finden Sie im Tutorial unter
Round-Trip Engineering (Code - Modell - Code).
1. Klicken Sie, nachdem Sie den Code importiert haben, in der Modellstruktur mit der
rechten Maustaste auf die main Methode der Klasse OrgChartTest und wählen Sie den
Befehl "Sequenzdiagramm generieren..."
Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung", angezeigt, in dem Sie die
Einstellungen dazu definieren können.
© 2016 Altova GmbH
Altova UModel 2017
264
UML-Diagramme
Verhaltensdiagramme
2. Wählen Sie die gewünschten Darstellungs- und Layout-Optionen aus und klicken Sie
anschließend auf OK, um das Diagramm zu generieren.
Mit den oben gewählten Einstellungen wird das unten gezeigte Sequenzdiagramm
erzeugt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
265
Anmerkungen:
Sie können nicht anzeigbaren Aufrufen eine spezielle Farbe zuweisen.
Die maximale Aufruftiefe definiert die Rekursionstiefe für das Diagramm.
Mit der Option "Zu ignorierende Namen" können Sie eine kommagetrennte Liste von
Typen definieren, die im Sequenzdiagramm nicht aufscheinen sollen, wenn es generiert
wird.
Mit der Option "Zu ignorierende Operationsnamen" können Sie eine kommagetrennte
Liste von Operationen definieren, die im generierten Sequenzdiagramm nicht aufscheinen
sollen (initComponents werden standardmäßig automatisch hinzugefügt).
Wenn Sie die Operationsnamen, z.B. "InitComponents", zur Liste hinzufügen, wird die
komplette Operation ignoriert. Wenn Sie der Operation in der Liste ein + (Pluszeichen)
voranstellen, z.B. +InitComponent, werden die Operationsaufrufe im Diagramm
angezeigt, jedoch ohne Inhalt.
Mit der Option "In kleinere Diagramme aufteilen, wo angebracht" werden
Sequenzdiagramme in kleinere Subdiagramme aufgeteilt, zwischen denen zur
einfacheren Navigation automatisch Hyperlinks angelegt werden.
Sequenzdiagramme werden automatisch aktualisiert, wenn Sie das komplette UModel-Projekt
© 2016 Altova GmbH
Altova UModel 2017
266
UML-Diagramme
Verhaltensdiagramme
aktualisieren. Sequenzdiagramme werden nicht aktualisiert, wenn Sie Klassen oder einzelne
Dateien extern aktualisieren. Sie können die Einstellung jedoch ändern, indem Sie auf den
Diagrammhintergrund klicken und das Kontrollkästchen "Automatische Aktualisierung" aktivieren.
Wenn Sie auf das
Symbol des Felds "Automatische Aktualisierung" klicken, wird das
Dialogfeld "Sequenzdiagrammgenerierung" geöffnet, in dem Sie die Einstellung für die
Generierung von Sequenzdiagrammen ändern können.
Generieren von Sequenzdiagrammen anhand von Eigenschaften
Sie können in UModel mehrere Sequenzdiagramme anhand mehrerer Optionen sowie
Sequenzdiagramm anhand von Getter / Setter-Eigenschaften generieren.
Erstellen mehrerer Sequenzdiagramme anhand mehrerer Operationen:
1. Wählen Sie die Menüoption Projekt | Sequenzdiagramme anhand von Code
generieren.
Daraufhin wird das Dialogfeld Wählen Sie eine oder mehrere Operationen aus
geöffnet.
2. Wählen Sie die Operationen aus, für die Sie ein Sequenzdiagramm generieren möchten,
und klicken Sie auf OK. (Verwenden Sie, wenn nötig, eine der Schaltflächen "Alle
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
267
öffentlichen auswählen" oder "Alles auswählen").
Wenn Sie auf OK klicken, wird das Dialogfeld "Sequenzdiagrammgenerierung" geöffnet,
in dem Sie weitere Optionen zur Generierung von Sequenzdiagrammen definieren können.
3. Klicken Sie auf OK, um die Sequenzdiagramme zu generieren.
Für jede der ausgewählten Operationen wird ein Sequenzdiagramm generiert.
Anmerkung: Sie können Getter und Setter nun beim Generieren von Sequenzdiagrammen
wahlweise inkludieren oder exkludieren.
Erstellen eines Sequenzdiagramms anhand von getter/setter-Eigenschaften
(C#, VB .NET)
1. Klicken Sie mit der rechten Maustaste auf eine Operation mit einem GetAccessor/
SetAccessor Stereotyp.
2. Wählen Sie im Kontextmenü die Option aus, mit der das gewünschte Sequenzdiagramm
generiert werden soll (Getter/Setter).
Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung" geöffnet, in dem Sie die
Eigenschaften für die Darstellung des Sequenzdiagramms einstellen können.
© 2016 Altova GmbH
Altova UModel 2017
268
UML-Diagramme
Verhaltensdiagramme
3. Klicken Sie auf OK, um das Sequenzdiagramm zu generieren.
Generieren von Code anhand von Sequenzdiagrammen
UModel kann Code anhand eines mit mindestens einer Operation verknüpften Sequenzdiagramms
generieren.
Die Generierung von Code anhand von Sequenzdiagrammen steht zur Verfügung für:
VB.NET, C# und Java
UModel Standalone Edition, Eclipse und Visual Studio Edition
alle drei UModel Editions
Code anhand von Sequenzdiagrammen kann auf zwei Arten erstellt werden:
durch einen Reverse Engineering Vorgang. Siehe dazu Generieren von
Sequenzdiagrammen anhand von Quellcode,
indem ein mit einer Operation verknüpftes Sequenzdiagramm von Grund auf neu erstellt
wird. Mit einem Rechtsklick auf die Operation in der Modell-Struktur können Sie über das
Kontextmenü den Befehl Sequenzdiagramm für Code erstellen aufrufen.
Anmerkungen:
Wenn Sie ein mit Reverse Engineering erstelltes Sequenzdiagramm als Basis verwenden,
vergewissern Sie sich, dass die Option "Code in Anmerkungen anzeigen" beim Reverse
Engineering aktiviert ist, damit kein Code verloren geht, wenn Sie wieder mit dem Forward
Engineering beginnen.
Dies ist darauf zurückzuführen, dass in einem UML-Sequenzdiagramm nicht alle Funktionen von
VB.NET, Java und C# angezeigt werden können. Daher werden diese Codeabschnitte in Form von
Code-Anmerkungen angezeigt.
So fügen Sie bei der Erstellung eines Sequenzdiagramms einfachen Text als Code
hinzu:
1. Hängen Sie eine Anmerkung an eine Lebenslinie in einem Sequenzdiagramm an.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
269
2. Geben Sie den Code ein, der in den endgültigen Quellcode geschrieben werden soll.
Aktivieren Sie im Bereich "Eigenschaften" das Kontrollkästchen "Ist Code", damit diese
Anmerkung zur Verfügung steht.
Ein Beispiel dazu finden Sie unter Hinzufügen von Code zu Sequenzdiagrammen.
Wenn bei jedem Start eines Code Engineering automatisch ein Sequenzdiagramm für das Code
Engineering verwendet werden soll:
aktivieren Sie im Bereich "Eigenschaften" das Kontrollkästchen "Für das Forward
Engineering verwenden", wenn das Sequenzdiagramm ausgewählt ist.
Der alte Code geht beim Forward Engineering von Code anhand eines Sequenzdiagramms immer
verloren, da er durch den neuen Code überschrieben wird.
Menü "Projekt":
1. Wählen Sie die Menüoption Projekt | Code von Sequenzdiagrammen generieren.
Daraufhin werden Sie aufgefordert, das/die gewünschten Sequenzdiagramm(e)
auszuwählen.
Wenn Sie auf die Schaltfläche "Alles auswählen" klicken, werden alle
Sequenzdiagramme im UModel-Projekt ausgewählt.
2. Klicken Sie auf OK, um den Code zu generieren.
Im Fenster "Meldungen" wird der Status der Codegenerierung angezeigt.
Model-Struktur:
Klicken Sie mit der rechten Maustaste auf ein Sequenzdiagramm und wählen Sie den
Befehl "Code von Sequenzdiagramm generieren".
© 2016 Altova GmbH
Altova UModel 2017
270
UML-Diagramme
Verhaltensdiagramme
Sequenzdiagramm, das Code einer Operation enthält:
1. Klicken Sie in den leeren Bereich des Sequenzdiagramms, das Code einer Operation
enthält.
2. Wählen Sie den Befehl "Code von Sequenzdiagramm generieren".
Mit diesem Befehl wird das Forward Engineering gestartet.
So erstellen Sie ein Sequenzdiagramm für Code (Engineering):
1. Klicken Sie in der Model-Struktur mit der rechten Maustaste auf eine Operation und
wählen Sie den Befehl "Sequenzdiagramm für Code erstellen".
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
271
Sie werden daraufhin gefragt, ob Sie das neue Diagramm für das Forward Engineering
verwenden möchten.
Das Ergebnis ist ein neues Sequenzdiagramm, das die Lebenslinie dieser Klasse enthält.
Hinzufügen von Code zu einem Sequenzdiagramm
Programmcode kann anhand eines neuen und eines mit Reverse Engineering erstellten
Sequenzdiagramms generiert werden, allerdings nur für ein Sequenzdiagramm, das mit der
"Hauptoperation" verknüpft ist.
Beim Reverse Engineering werden Standardelemente des Sequenzdiagramms, wie z.B.
CombinedFragments Codierungselementen (z.B. "if" Anweisungen, Schleifen usw.) "zugewiesen"
bzw. auf diese "gemappt".
Bei Programmanweisungen, für die es keine entsprechenden Sequenzdiagrammelemente gibt,
wie z.B. "i = i+1" werden in UModel "Code- Anmerkungen" verwendet, um Code zu Diagrammen
hinzuzufügen. Diese Anweisungen müssen anschließend mit der Lebenslinie verknüpft werden.
Beachten Sie, dass UModel diese Codefragmente nicht überprüft oder parst. Sie müssen vorher
sicherstellen, dass die Codefragmente korrekt und kompilierbar sind.
So fügen Sie Code zu einem Sequenzdiagramm hinzu:
1. Klicken Sie auf die Schaltfläche "Anmerkung"
© 2016 Altova GmbH
und klicken Sie anschließend auf
Altova UModel 2017
272
UML-Diagramme
Verhaltensdiagramme
das Modellelement, an dem diese eingefügt werden soll, z.B. CombinedFragment.
2 Geben Sie das Codefragment ein, z.B. return.
3. Klicken Sie auf den Ziehpunkt der eingefügten Anmerkung und ziehen Sie den Cursor auf
die Lebenslinie.
4. Aktivieren Sie auf dem Register "Eigenschaften" das Kontrollkästchen "Ist Code", damit
dieses Codefragment bei der Codegenerierung inkludiert wird.
Wenn Sie eine Anmerkung in einem Sequenzdiagramm auswählen, die zur Codegenerierung
verwendet werden kann, so steht die Eigenschaft "Ist Code" im Fenster "Eigenschaften" zur
Verfügung. Durch Aktivieren/Deaktivieren des Kontrollkästchens können Sie zwischen "normalen"
Anmerkungen und Codegenerierungsanmerkungen wechseln.
Normale
Anmerkungen:
Codegenerierungsanm
erkungen
- werden mit einem schattierten Eck
angezeigt
Wenn das Kontrollkästchen "Für das Forward Engineering verwenden" aktiviert ist, wird der Code
automatisch bei jedem Forward Engineering aktualisiert. Wenn Änderungen am
Sequenzdiagramm vorgenommen wurden, wird der Code der Operation immer überschrieben.
Das unten gezeigte Sequenzdiagramm wurde durch Rechtsklick auf die OnCommand-Operation
und Auswahl des Befehls "Sequenzdiagramm von Code generieren" generiert. Der C# Code
dieses Beispiels steht im Ordner c:\Documents and Settings\<user>\My Documents\Altova
\UModel2012\UModelExamples\IDEPlugIn\Styles\ zur Verfügung. Über die Option "Projekt |
Quellprojekt importieren können Sie das Projekt importieren.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
273
Anhand dieses Sequenzdiagramms wird der unten gezeigte Code generiert.
Public void OnCommand(int nID, object pUModel)
{
//Generated by UModel. This code will be overwritten when you re-run code
generation.
if (!m_bPlugINVersionOK)
{
return;
}
if (nID == 3 || nID == 6)
{
OnSetStyles((IApplication)pUModel, "red");
}
if (nID == 4 || nID == 7)
© 2016 Altova GmbH
Altova UModel 2017
274
UML-Diagramme
Verhaltensdiagramme
{
OnSetStyles((IApplication)pUModel, "green");
}
GC.Collect();
}
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.1.8
Verhaltensdiagramme
275
Altova Website:
UML-Zeitverlaufsdiagramme
Zeitverlaufsdiagramme dienen zum Darstellen von Änderungen am Status oder Zustand von einem
oder mehreren miteinander in Wechselbeziehung stehenden Objekten über einen bestimmten
Zeitraum. Zustände werden in Form von Zeitlinien dargestellt, die auf Message Events reagieren,
wobei eine Lebenslinie eine Classifier Instance oder Classifier Role darstellt.
Bei Zeitverlaufsdiagrammen handelt es sich um eine Sonderform eines Sequenzdiagramms. Im
Unterschied zum Sequenzdiagramm sind beim Zeitverlaufsdiagramm die Achsen vertauscht, d.h.
der Zeitverlauf wird aufsteigend von links nach rechts dargestellt und Lebenslinien werden in
separaten vertikal angeordneten Bereichen angezeigt.
Zeitverlaufsdiagramme werden im Allgemeinen zum Entwerfen von eingebetteter Software oder
Echtzeitsystemen verwendet.
Es gibt zwei verschiedene Arten von Zeitverlaufsdiagrammen: Die eine Art enthält, wie oben
gezeigt, eine Zustands-Zeitlinie, die andere allgemeinere Art enthält, wie unten gezeigt, eine
Lebenslinie.
© 2016 Altova GmbH
Altova UModel 2017
276
UML-Diagramme
Verhaltensdiagramme
Einfügen von Elementen des Zeitverlaufsdiagramms
1. Klicken Sie in der Zeitverlaufsdiagramm-Symbolleiste auf das entsprechende
Zeitverlaufselement.
2. Klicken Sie zum Einfügen des Elements in das Zeitverlaufsdiagramm. Um mehrere
Ziehen vorhandener Elemente in das Zeitverlaufsdiagramm:
Sie können Elemente aus anderen Diagrammen, z.B. Klassen, in ein Zeitverlaufsdiagramm
einfügen.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (über das
Suchfunktionstextfeld oder durch Drücken der Tasten Strg + F).
2. Ziehen Sie das Element/die Elemente in das Diagramm.
Lebenslinie
oder
Lebenslinie
Das Element "Lebenslinie" bildet einen Teil einer Interaktion und steht in zwei Formen zur
Verfügung: als Zustands-Zeitlinie oder als Wertverlaufslinie. Um eine Lebenslinie mit mehreren
Zeilen zu erstellen, drücken Sie Strg + Eingabetaste, um eine neue Zeile anzulegen.
So fügen Sie eine Zustands-Lebenslinie (Zustandsinvariante) ein und definieren
Zustandsänderungen:
1. Klicken Sie auf das Symbol "Lebenslinie (Zustand)"
in der Titelleiste und
anschließend in das Zeitverlaufsdiagramm, um die Lebenslinie einzufügen.
2. Geben Sie einen Namen für die Lebenslinie ein, um den Standardnamen (Lebenslinie1)
wenn nötig zu ändern.
3. Platzieren Sie den Mauszeigen über einen Abschnitt einer der Zeitlinien und klicken Sie
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
277
auf die linke Maustaste. Daraufhin wird die Linie ausgewählt.
4. Verschieben Sie den Mauszeiger an die Stelle, an der die Zustandsänderung eintreten
soll, und klicken Sie nochmals auf die linke Maustaste.
Beachten Sie: Während dieses Vorgangs wird ein Pfeil mit zwei Spitzen angezeigt.
An der Klickposition erscheint ein rotes Kästchen, das die Zeile an diesem Punkt teilt.
5. Ziehen Sie den Cursor auf der Linie nach rechts und ziehen Sie die Linie nach oben.
Beachten Sie, dass die Linien nur zwischen bestehenden Zuständen der aktuellen
Lebenslinie verschoben werden kann.
Sie können beliebig viele Zustandsänderungen pro Lebenslinie definieren. Wenn auf einer
Linie ein rotes Kästchen angezeigt wird, können Sie an eine beliebige Stelle im
Diagramm klicken, um es zu löschen.
So fügen Sie einen neuen Zustand zur Lebenslinie hinzu:
1. Rechtsklicken Sie auf die Lebenslinie und wählen Sie Neu | Zustand
(Zustandsinvariante).
Daraufhin wird ein neuer Zustand, z.B. Zustand2 zur Lebenslinie hinzugefügt.
So verschieben Sie einen Zustand innerhalb einer Lebenslinie:
1. Klicken Sie auf die Beschriftung des Zustands, den Sie verschieben möchten.
2. Ziehen Sie den Zustand an eine andere Stelle innerhalb der Lebenslinie.
So löschen Sie einen Zustand aus einer Lebenslinie:
1. Klicken Sie auf den Zustand und drücken Sie die Entf-Taste oder klicken Sie auf die
rechte Maustaste und wählen Sie den Befehl "Löschen".
So wechseln Sie zwischen Zeitverlaufsdiagrammtypen:
1. Klicken Sie auf das Symbol "Darstellung wechseln" rechts unterhalb der Lebenslinie.
© 2016 Altova GmbH
Altova UModel 2017
278
UML-Diagramme
Verhaltensdiagramme
Daraufhin wird stattdessen eine Wertverlaufslebenslinie angezeigt, der Kreuzungspunkt
stellt eine Änderung eines Zustands/Werts dar.
Beachten Sie bitte: Wenn Sie auf das Symbol "Lebenslinie (allgemeiner Wert)
klicken, wird die oben gezeigte Lebenslinie eingefügt. Sie können jederzeit zwischen
den beiden Darstellungen wechseln.
So fügen Sie einen neuen Zustand zur Wertverlaufslebenslinie hinzu:
1. Rechtsklicken Sie auf die Lebenslinie und wählen Sie Neu | Zustand
(Zustandsinvariante).
2. Bearbeiten Sie den neuen Namen, z.B. Zustand3 und bestätigen Sie die Änderung mit
der Eingabetaste.
Daraufhin wird ein neuer Zustand zur Lebenslinie hinzugefügt.
Gruppieren von Lebenslinien
Beim Platzieren oder Stapeln von Lebenslinien werden diese automatisch korrekt angeordnet,
wobei auch hinzugefügte Häkchen erhalten bleiben. Durch Ziehen des entsprechenden
Nachrichtenobjekts können auch Nachrichten zwischen separaten Lebenslinien erstellt werden.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
279
Tick-Symbol
Tick-Symbol
Dieses Symbol dient zum Einfügen der Tick-Symbole eines Zeitverlaufslineals auf einer
Lebenslinie.
So fügen Sie ein Tick-Symbol ein:
1. Klicken Sie auf das Tick-Symbol in der Symbolleiste und anschließend auf die
Lebenslinie, um es einzufügen.
2. Um mehrere Tick-Symbole einzufügen, halten Sie die Strg-Taste gedrückt, während Sie
auf verschiedene Positionen am Rand der Lebenslinie klicken.
3. Geben Sie in das dafür vorgesehene Feld eine Beschriftung für das Tick-Symbol ein.
Zum Neupositionieren der Tick-Symbole auf der Lebenslinie ziehen Sie die Symbole mit
der Maus an die gewünschte Stelle.
So ordnen Sie die Tick-Symbole in gleichmäßigen Abständen auf einer
Lebenslinie an:
1. Ziehen Sie im Hauptfenster ein Rechteck auf, um die einzelnen Tick-Symbole zu
markieren.
2. Klicken Sie in der Symbolleiste auf das Symbol Waagrecht anordnen
© 2016 Altova GmbH
.
Altova UModel 2017
280
UML-Diagramme
Verhaltensdiagramme
Auslösendes Ereignis
Das ExecutionEvent "Auslösendes Ereignis" dient dazu, eine Änderung im Zustand eines Objekts
anzuzeigen, die durch das entsprechende auslösende Ereignis verursacht wurde. Die
eingehenden Ereignisse werden mit einer Beschriftung versehen, um das Ereignis zu
kennzeichnen, das die Zustandsänderung verursacht.
So fügen Sie ein auslösendes Ereignis ein:
1. Klicken Sie auf das Symbol "Auslösendes Ereignis" und anschließend auf die
entsprechende Stelle auf der Zeitlinie, an der die Veränderung stattfindet.
2. Geben Sie einen Namen für das Ereignis ein. In diesem Beispiel heißt das Ereignis
"Code".
Beachten Sie, dass die Eigenschaften des Ereignisses auf dem Register "Eigenschaften"
angezeigt werden.
Zeitdauerbedingung
Zeitdauerbedingung
Eine Zeitdauer definiert eine Wertespezifikation zur Angabe einer Zeitdauer zwischen einem Startund einem Endpunkt. Eine Zeitdauer ist oft ein Ausdruck zur Darstellung der Ticks der Uhr, die
während dieser Zeitdauer verstreichen.
So fügen Sie eine Zeitdauerbedingung ein:
1. Klicken Sie auf das Symbol "Zeitdauerbedingung" und anschließend auf die Stelle auf der
Lebenslinie, an der die Bedingung angezeigt werden soll.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
281
Die Standard-Minimum- und Maximum-Werte "d..t" werden automatisch vorgegeben.
Durch Doppelklick auf die Zeitdauerbedingung oder durch Bearbeitung der Werte im
Fenster "Eigenschaften" können Sie diese Werte bearbeiten.
2. Mit Hilfe der Ziehpunkte können Sie die Größe des Objekts gegebenenfalls anpassen.
Ändern der Ausrichtung der Zeitdauerbedingung:
1. Klicken Sie auf das "Umdrehen"-Symbol, zum die Bedingung vertikal auszurichten.
Zeitbedingung
Eine Zeitbedingung wird im Allgemeinen als grafische Assoziation zwischen einem Zeitintervall
und dem Konstrukt, das es einschränkt, dargestellt. Normalerweise handelt es sich um eine
grafischen Assoziation zwischen dem Auftreten eines Ereignisses und einem Zeitintervall.
So fügen Sie eine Zeitbedingung ein:
1. Klicken Sie auf das Symbol "Zeitbedingung" und anschließend auf die entsprechende
Position auf der Lebenslinie, an der die Bedingung angezeigt werden soll.
© 2016 Altova GmbH
Altova UModel 2017
282
UML-Diagramme
Verhaltensdiagramme
Die Standard-Minimum- und Maximum-Werte "d..t" werden automatisch vorgegeben.
Durch Doppelklick auf die Zeitbedingung oder durch Bearbeitung der Werte im Fenster
"Eigenschaften" können Sie diese Werte bearbeiten.
Nachricht
Message (Aufruf)
Nachricht (Antwort)
Eine Nachricht ist ein Modellierungselement, das eine bestimmte Art von Kommunikation in einer
Interaktion definiert. Dabei kann es sich z.B. um das Auslösen eines Signals, den Aufruf einer
Operation, das Erstellen oder Löschen einer Instanz handeln. Die Nachricht definiert die Art der
durch die absendende Ausführungsspezifikation definierten Kommunikation sowie den Absender
und den Empfänger.
Nachrichten werden zwischen sendenden und empfangenden Zeitlinien gesendet und werden als
beschriftete Pfeile angezeigt.
1. Klicken Sie auf das entsprechende Nachrichtensymbol in der Symbolleiste.
2. Klicken Sie an eine beliebige Stelle auf der Zeitlinie für das sendende Objekt, z.B. auf
Idle.
3. Ziehen Sie die Nachrichtenlinie auf die Zeitlinie der empfangenden Objekte, z.B. NoCard.
Die Lebenslinie erscheint markiert, wenn die Nachricht an diese bestimmte Stelle
gezogen werden kann.
Die Richtung, in die Sie den Pfeil ziehen, bestimmt die Richtung der Nachricht.
können Sie mehrere Nachrichten einfügen, indem Sie mehrmals ins Diagramm klicken
und die Maus ziehen.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Verhaltensdiagramme
283
So löschen Sie eine Nachricht:
1. Klicken Sie auf die gewünschte Nachricht.
2. Drücken Sie die Entf-Taste, um die Nachricht aus dem Modell zu löschen oder
rechtsklicken Sie darauf und wählen Sie den Befehl "Aus Diagramm löschen".
© 2016 Altova GmbH
Altova UModel 2017
284
UML-Diagramme
9.2
Strukturdiagramme
Strukturdiagramme
Diese Diagramme dienen zur Darstellung der Strukturelemente, aus denen ein System oder eine
Funktion besteht. Es werden sowohl die statischen, z.B. Klassendiagramm, als auch die
dynamischen Beziehungen, z.B. Objektdiagramm, dargestellt.
Strukturdiagramme
Klassendiagramm
Komponentendiagramm
Deployment-Diagramm
Objektdiagramm
Paketdiagramm
Profildiagramm
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.2.1
Strukturdiagramme
285
Klassendiagramm
Dieser Abschnitt enthält die folgenden Kapitel zu Aufgaben und Begriffen im Zusammenhang mit
Klassendiagrammen:
Anpassen von Klassendiagrammen
Außerkraftsetzen von Basisklassenoperationen und Implementieren von
Schnittstellenoperationen
Erstellen von Getter / Setter-Methoden
Ball-and-socket Notation
Hinzufügen von Ausnahmeereignissen zu Methoden einer Klasse
Generieren von Klassendiagrammen
Eine grundlegende Einführung in Klassendiagramme finden Sie unter Klassendiagramme im
Abschnitt "Tutorial" diese Dokumentation.
Anpassen von Klassendiagrammen
Erweitern / Ausblenden von Klassenbereichen in einem UML-Diagramm:
Es gibt verschiedene Methoden, um die verschiedenen Bereiche von Klassendiagrammen zu
erweitern.
Klicken Sie auf das + bzw. das - Symbol der gerade aktiven Klasse, um den jeweiligen
Bereich zu erweitern/auszublenden.
Ziehen Sie ein Rechteck (über dem Diagrammhintergrund) auf, um mehrere Klassen zu
markieren und klicken Sie anschließend die Schaltfläche "Erweitern/Ausblenden". Sie
können mehrere Klassen auch mit Hilfe von Strg+Klick auswählen.
Drücken Sie Strg + A, um alle Klassen auszuwählen. Klicken Sie anschließend in einer
der Klassen auf die Schaltfläche "Erweitern/Reduzieren", um die entsprechenden
Bereiche zu erweitern bzw. zu reduzieren.
Erweitern/Reduzieren von Klassenbereichen in der Modellstruktur:
In der Modellstruktur sind Klassen Unterelemente von Paketen und Sie können entweder die
Pakete oder die Klassen erweitern bzw. reduzieren.
Klicken Sie auf das Paket / die Klasse um es/sie zu erweitern und:
Drücken Sie die *-Taste, um das aktuelle Paket/die aktuelle Klasse und alle Subelemente zu
erweitern
Drücken Sie die +-Taste um das aktuelle Paket/die aktuelle Klasse zu öffnen.
Um das Paket/die Klassen zu reduzieren, drücken Sie die - Taste.
Sie können dazu die Standardtasten der Tastatur oder die Tasten des Ziffernblocks verwenden.
Ändern der Symbole für die Sichtbarkeit
© 2016 Altova GmbH
Altova UModel 2017
286
UML-Diagramme
Strukturdiagramme
Wenn Sie auf das Sichtbarkeitssymbol links von einer Operation
oder Eigenschaft
klicken,
wird eine Dropdown-Liste geöffnet, in der Sie den Sichtbarkeitsstatus ändern können. Sie können
auch ändern, welche Art von Sichtbarkeitssymbol angezeigt werden soll.
Klicken Sie im Diagrammfenster auf eine Klasse, anschließend auf das Register Stile
und scrollen Sie in der Liste hinunter bis zum Eintrag Sichtbarkeit anzeigen..
Sie können wählen zwischen dem oben gezeigten UModel Typ und den unten gezeigten
UML-konformen Symbolen.
Ein-/Ausblenden von Knoteninhalt (Klassenattribute, Operationen, Slots)
Sie können in UModel nun die Attribute oder Operationen einer Klasse einzeln ein- oder
ausblenden und definieren, welche angezeigt werden sollen, wenn Sie diese als neue Elemente
hinzufügen. Beachten Sie bitte: Sie können nun auch Objekt-Slots, also Instanzspezifikationen
mit derselben Methode ein- und ausblenden.
Rechtsklicken Sie auf eine Klasse z.B. SavingsAccount und wählen Sie die Menüoption
Knoteninhalt ein-/ausblenden.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
287
Wenn Sie in der Gruppe Attribute das Kontrollkästchen protected deaktivieren, werden die
"protected" Attribute im Vorschaufenster deaktiviert.
Sobald Sie die Auswahl mit OK bestätigen, werden die protected Attribute in der Klasse durch
drei Punkte "..." ersetzt. Wenn Sie auf die drei Punkte doppelklicken, wird das Dialogfeld geöffnet.
Beachten Sie: Einzelne Attribute können davon betroffen sein, wenn Sie nur das Kontrollkästchen
im Vorschaufenster deaktivieren.
Ein- / Ausblenden von Klassenattributen oder Operationen - Elementstile
Sie können in UModel mehrere Instanzen derselben Klasse in einem einzigen Diagramm oder
sogar in mehreren Diagrammen einfügen. Die Sichtbarkeitseinstellungen können für jede einzelne
dieser "Ansichten" der Klasse separat definiert werden. In der Abbildung unten sehen Sie zwei
Ansichten derselben Klasse, nämlich SavingsAccount.
Mit Hilfe der Option "Beim Hinzufügen neuer Elemente, die nicht durch Elementstile ausgeblendet
werden" können Sie festlegen, was sichtbar gemacht werden soll, wenn neue Elemente zur
Klasse hinzugefügt werden. Elemente können manuell oder automatisch während der
Codegenerierung zum Modelldiagramm hinzugefügt werden.
Elemente anzeigen: Zeigt alle neuen Elemente, die zu einer beliebigen Klassenansicht
© 2016 Altova GmbH
Altova UModel 2017
288
UML-Diagramme
Strukturdiagramme
hinzugefügt werden.
So wurde z.B. das Attribut interestRate:float in beiden "Ansichten" von SavingsAccount
ausgeblendet, sodass das Attribut minimumBalance sichtbar bleibt. Das Optionsfeld "Elemente
anzeigen" ist für die Klasse auf der linken Seite aktiv.
Wenn Sie in der linken Klasse auf die Auslassungspunkte "..." im Attributbereich
doppelklicken, sehen Sie, dass das Optionsfeld "Elemente anzeigen" aktiv ist.
Wenn Sie in der rechten Klasse auf die Auslassungspunkte "..." im Attributbereich
doppelklicken, sehen Sie, dass das Optionsfeld "Elemente ausblenden (mit Ausnahme der zu
diesem Knoten hinzugefügten)" aktiv ist.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
289
Wenn Sie auf die linke Klasse klicken und F7 drücken (oder in der Modellstruktur auf die Klasse
klicken und F7 drücken), wird ein neues Attribut (Property1) zur Klasse hinzugefügt.
Das neue Element ist nur in der linken Klasse sichtbar, da hier die Option "Elemente anzeigen"
aktiv ist. In der rechten Klasse ist die Option "Elemente ausblenden..." aktiv, sodass das neue
Element hier nicht angezeigt wird.
Wenn Sie auf die rechte Klasse klicken und F7 drücken, wird ein neues Attribut (Property2) zur
Klasse hinzugefügt. Dieses neue Attribut ist nun sichtbar, da in der Einstellung "Elemente
ausblenden..." spezifiziert ist "mit Ausnahme der zu diesem Knoten hinzugefügten", wobei
als Knoten diese Klasse bzw. dieses Modellierungselement bezeichnet wird.
© 2016 Altova GmbH
Altova UModel 2017
290
UML-Diagramme
Strukturdiagramme
Das Attribut Property2 ist auch in der linken Klasse sichtbar, da als Einstellung hier "Elemente
anzeigen" gewählt wurde.
Bitte beachten Sie:
Die Eigenschaftswerte von ausgeblendeten Elementen werden auch ausgeblendet, wenn Sie die
Option "Ausblenden" auswählen.
Ein- /Ausblenden von VS .NET-Bereichen:
UModel kann nun .NET-Eigenschaften in ihrem eigenen Bereich anzeigen. Aktivieren Sie dazu auf
dem Register "Stile" die Option ".NET-Eigenschaften in eigenem Bereich anzeigen".
Anzeige von VS .NET-Eigenschaften als Assoziationen
UModel kann .NET-Eigenschaften nun als Assoziationen anzeigen.
Klicken Sie mit der rechten Maustaste wie unten gezeigt auf eine C#-Eigenschaft, wählen Sie den
Befehl "Anzeigen | Alle .NET-Eigenschaften als Assoziationen" und ziehen Sie die Operation in
das Diagramm.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
291
Ändern der Syntaxfarbe von Operationen/Eigenschaften
Die Syntaxfärbung ist in UModel automatisch aktiviert. Sie können die Syntaxfarben allerdings
nach Ihren eigenen Wünschen anpassen. Unten sehen Sie die Standardeinstellungen.
So ändern Sie die Standardeinstellung für die Syntaxfarben (siehe unten):
1. Wechseln Sie zum Register "Stile" und scrollen Sie zu den vordefinierten SF-Einträgen.
2. Ändern Sie einen der SF-Farbeinträge, z.B. SF-Typ zu rot.
So deaktivieren Sie die Syntaxfärbung:
1. Wechseln Sie zum Register "Stile" und ändern Sie den Eintrag Syntaxfarben
verwenden in false.
2. Über die Einträge Attributfarbe oder Operation Farbe auf dem Register "Stile" können
Sie diese Einstellungen in der Klasse ändern.
© 2016 Altova GmbH
Altova UModel 2017
292
UML-Diagramme
Strukturdiagramme
Außerkraftsetzen von Basisklassenoperationen und Implementieren von
Schnittstellenoperationen
Sie haben in UModel die Möglichkeit, die Basisklassenoperationen/Schnittstellen vor der Code
Engineering-Phase außer Kraft zu setzen oder Schnittstellenoperationen einer Klasse zu
implementieren. Die kann über die Modell-Struktur, das Register "Favoriten" oder in
Klassendiagrammen durchgeführt werden.
1. Rechtsklicken Sie auf eine der abgeleiteten Klassen im Klassendiagramm, z.B. auf
CheckingAccount und wählen Sie den Befehl Operationen überschreiben/
implementieren.
Daraufhin wird das unten gezeigte Dialogfeld geöffnet.
2. Wählen sie die Operationen aus, die Sie außer Kraft setzen möchten und bestätigen Sie
mit OK.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
293
Mit Hilfe der Schaltflächen "Nicht definierte...auswählen" werden die jeweiligen
Methodenarten im Fenster auf der linken Seite ausgewählt.
Bitte beachten Sie:
Beim Öffnen des Dialogfelds werden Operationen von Basisklassen und implementierten
Schnittstellen, die dieselbe Signatur wie bestehende Operationen haben, automatisch
ausgewählt, d.h. aktiviert.
Erstellen von Getter / Setter-Methoden
Während des Modellierens müssen oft get/set-Methoden für bestehende Attribute erstellt werden.
UModel bietet für diesen Zweck zwei separate Methoden:
Verschieben eines Attributs mit Hilfe von Drag and Drop in den Operation-Bereich
Verwendung des Kontextmenüs zum Öffnen eines Dialogfelds, in dem Sie die get/setMethoden verwalten können
So erstellen Sie Getter/Setter-Methoden mittels Drag and Drop:
1. Ziehen Sie ein Attribut aus dem Attribut-Bereich in den Operations-Bereich.
Daraufhin wird ein Popup-Fenster angezeigt, in dem Sie auswählen können, welche Art
von get/set-Methode erstellt werden soll.
Wenn Sie den ersten Eintrag auswählen, wird eine get- und set-Methode für
interestRate:float erstellt.
© 2016 Altova GmbH
Altova UModel 2017
294
UML-Diagramme
Strukturdiagramme
So erstellen Sie Getter/Setter-Methoden über das Kontextmenü:
1. Rechtsklicken Sie auf den Namen einer Klasse, z.B. SavingsAccount und wählen Sie im
Kontextmenü die Option Getter/Setter-Operationen erstellen.
Daraufhin erscheint das Dialogfeld "Getters/Setters erstellen", in dem alle in der derzeit
aktiven Klasse vorhandenen Attribute angezeigt werden.
2. Verwenden Sie die Schaltflächen, um die Einträge als Gruppe auszuwählen oder klicken
Sie auf die Kontrollkästchen der einzelnen Methoden.
Bitte beachten Sie:
Sie können auch auf ein einzelnes Attribut rechtsklicken und auf dieselbe Art eine
Operation dafür erstellen.
Ball-and-socket Notation
UModel unterstützt die Ball-and-socket Notation von UML-Klassen, die eine Schnittstelle
benötigen, ein "Socket" (Buchse) und den Schnittstellennamen anzeigen, während Klassen, die
eine Schnittstelle implementieren den "ball" (Stecker) anzeigen.
In den Abbildungen oben realisiert Class2 Interface1, welche von den Klassen 1, 3 und 4
verwendet wird. Die Verwendungssymbole dienten zum Erstellen der Verwendungsbeziehung
zwischen den Klassen und der Schnittstelle.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
295
So wechseln Sie zwischen der Standard- und der Ball-and-socket-Ansicht:
Klicken Sie auf das Symbol "Darstellung wechseln" am unteren Rand des
Schnittstellenelements.
Hinzufügen von Ausnahmeereignissen zu Methoden einer Klasse
So fügen Sie Ausnahmeereignisse zu Methoden einer Klasse hinzu:
1. Klicken Sie im Fenster "Modellstruktur" auf die Methode der Klasse, zu der Sie das
Ausnahmeereignis hinzufügen möchten, z.B. in der Klasse "Account" auf getBalance.
2. Rechtsklicken Sie in das Fenster "Eigenschaften" und wählen Sie im Popup-Menü den
Befehl Ausnahmeereignis hinzufügen.
Daraufhin wird das Feld "Ausnahmeereignis" zum Fenster "Eigenschaften" hinzugefügt
und der erste Eintrag im Popup-Menü wird automatisch markiert.
3. Wählen Sie einen Eintrag im Popup-Menü aus oder geben Sie Ihren eigenen in das Feld
ein.
© 2016 Altova GmbH
Altova UModel 2017
296
UML-Diagramme
Strukturdiagramme
Generieren von Klassendiagrammen
Anstatt Klassendiagramme direkt in UModel zu erstellen, können Sie diese beim Import von
Quellcode oder Binärdateien in UModel-Projekte automatisch generieren (siehe Importieren von
Quellcode in Projekte und Importieren von Java-, C#- und VB-Binärdateien). Wenn Sie den
Assistenten verwenden, achten Sie auf folgende Dinge:
1) Im Dialogfeld "Quellprojekt importieren", "Binärtypen importieren" bzw. "Quellverzeichnis
importieren" muss das Kontrollkästchen Diagrammgenerierung aktivieren aktiviert sein.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
297
Dialogfeld "Quellproj ekt importieren"
2) Im Dialogfeld "Generierung von Inhaltsdiagrammen"müssen die Optionen Einzelnes
Diagramm generieren und/oder Diagramm pro Paket generieren aktiviert sein.
© 2016 Altova GmbH
Altova UModel 2017
298
UML-Diagramme
Strukturdiagramme
Dialogfeld "Generierung von Inhaltsdiagrammen"
Nach Fertigstellung des Imports stehen die generierten Klassendiagramme in der DiagrammStruktur unter "Klassendiagramme" zur Verfügung.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
299
Diagramm-Struktur
© 2016 Altova GmbH
Altova UModel 2017
300
UML-Diagramme
9.2.2
Altova Website:
Strukturdiagramme
UML-Kompositionsstrukturdiagramme
In UML 2.0 wurde das Kompositionsstrukturdiagramm hinzugefügt. Es dient dazu, die interne
Struktur einschließlich Bereichen, Ports und Konnektoren eines strukturierten Classifier oder
einer Kollaboration anzuzeigen.
Einfügen von Elementen eines Kompositionsstrukturdiagramms
Über die Schaltflächen der Symbolleiste:
1. Klicken Sie in der Symbolleiste auf das jeweilige Kompositionsstrukturdiagramm-Symbol.
2. Klicken Sie in das Kompositionsstrukturdiagramm, um das Element einzufügen. Um
mehrere Elemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste
gedrückt und klicken Sie in das Diagrammfenster.
Ziehen bestehender Elemente in das Kompositionsstrukturdiagramm:
Die meisten Elemente, die in anderen Kompositionsstrukturdiagrammen vorkommen, können in
ein bestehendes Kompositionsstrukturdiagramm eingefügt werden.
2. Ziehen Sie das/die Element(e) in das Kompositionsstrukturdiagramm.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
301
Kollaboration
Fügt ein Kollaborationselement ein. Dabei handelt es sich um eine Art von Classifier/Instanz, der/
die mit anderen Instanzen kommuniziert, um das Verhalten des Systems zu erzeugen.
Kollaborationsanwendung
Fügt ein Kollaborationsanwendungselement ein. Dabei handelt es sich um eine bestimmte
Kollaborationsanwendung, wobei bestimmte Klassen oder Instanzen die Rolle der Kollaboration
spielen. Eine Kollaborationsanwendung wird als strichlierte Ellipse angezeigt, die den Namen der
Instanz, einen Doppelpunkt und den Namen des Kollaborationstyps enthält.
Beim Erstellen von Abhängigkeiten zwischen Kollaborationsanwendungselementen muss das
Feld "Typ" ausgefüllt sein, damit eine Rollenbindung erstellt werden kann und die Zielkollaboration
muss mindestens einen Part/eine Rolle haben.
Part (Eigenschaft)
Fügt ein Part-Element ein, das eine Gruppe von einer oder mehreren Instanzen darstellt, die ein
Classifier besitzt, der diese enthält. Ein Part kann zu Kollaborationen und Klassen hinzugefügt
werden.
Port
Fügt ein Port-Element ein, das den Interaktionspunkt zwischen einem Classifier und seiner
Umgebung definiert. Ein Port-Element kann zu einem Part-Elementen mit einem definierte Typ
hinzugefügt werden.
Klasse
Fügt ein Klassenelement ein. Dabei handelt es sich um den eigentlichen Classifier, der in dieser
bestimmten Verwendung der Kollaboration vorkommt.
Konnektor
Fügt ein Konnektorelement hinzu, das verwendet werden kann, um zwei oder mehr Instanzen
eines Teils oder Ports zu verbinden. Der Konnektor definiert die Beziehung zwischen den
Objekten und identifiziert die Kommunikation zwischen den Rollen.
Abhängigkeit (Rollenbindung)
Fügt das Abhängigkeitselement ein. Dieses Element zeigt an, welches verbindbare Element des
© 2016 Altova GmbH
Altova UModel 2017
302
UML-Diagramme
Strukturdiagramme
Classifiers oder der Operation welche Rolle in der Kollaboration spielt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.2.3
Strukturdiagramme
303
Komponentendiagramm
Eine Anleitung zum Hinzufügen von Komponentenelementen zum Diagramm finden Sie im Tutorial
im Abschnitt Komponentendiagramme.
© 2016 Altova GmbH
Altova UModel 2017
304
UML-Diagramme
9.2.4
Deployment-Diagramm
Strukturdiagramme
Eine Anleitung zum Hinzufügen von Knoten und Artefakten zum Diagramm finden Sie im Tutorial
im Abschnitt Deployment-Diagramme.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.2.5
Strukturdiagramme
305
Objektdiagramm
Eine Anleitung zum Hinzufügen neuer Objekte/Instanzen zum Diagramm finden Sie im Tutorial im
Abschnitt Objektdiagramme.
© 2016 Altova GmbH
Altova UModel 2017
306
UML-Diagramme
9.2.6
Paketdiagramm
Strukturdiagramme
In Paketdiagrammen werden die Struktur von Paketen und ihren Elementen sowie die
entsprechenden Namespaces angezeigt. Zusätzlich dazu können Sie in UModel einen Hyperlink
erstellen und zum jeweiligen Inhalt des Pakets navigieren.
Pakete werden als Ordner dargestellt und können in jedem der UML-Diagramme verwendet
werden. Sie werden jedoch hauptsächlich in Use Case- und Klassendiagrammen verwendet.
Automatische Generierung von Paketabhängigkeiten
UModel bietet die Möglichkeit, ein Paketabhängigkeitsdiagramm für jedes beliebige in der ModellStruktur bereits existierende Paket zu generieren.
Abhängigkeitslinks zwischen Paketen werden erstellt, wenn Referenzen zwischen den
Modellierungselementen dieser Pakete vorhanden sind, d.h. wenn es Abhängigkeiten zwischen
Klassen, abgeleitete Klassen oder Attributen gibt, die Typen haben, die in einem anderen Paket
definiert sind.
So generieren Sie ein Paketabhängigkeitsdiagramm:
1. Rechtsklicken Sie auf ein Paket in der Modell-Struktur, z.B. altova und wählen Sie den
Befehl In neuem Diagramm anzeigen | Paketabhängigkeiten... .
Daraufhin wird das Dialogfeld "Neues Paketabhängigkeitsdiagramm" geöffnet.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
307
2. Wählen Sie die gewünschten Optionen aus und klicken Sie zur Bestätigung auf OK.
Es wird ein neues Diagramm generiert, in dem die Paketabhängigkeiten des Pakets
"altova" angezeigt werden.
Einfügen von Paketdiagrammelementen
1. Klicken Sie in der Paketdiagramm-Symbolleiste auf das entsprechende Symbol.
2. Klicken Sie in das Diagramm, um das Element einzufügen. Um mehrere Elemente des
ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt und klicken Sie in
das Diagrammfenster.
Ziehen vorhandener Elemente in das Paketdiagramm:
Sie können Elemente aus anderen Diagrammen, z.B. Pakete, in ein Paketdiagramm einfügen.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (über das
Suchfunktionstextfeld oder durch Drücken der Tasten Strg + F).
2. Ziehen Sie das Element/die Elemente in das Diagramm.
Paket
© 2016 Altova GmbH
Altova UModel 2017
308
UML-Diagramme
Strukturdiagramme
Fügt das Paketelement in das Diagramm ein. Pakete dienen zum Gruppieren von Elementen und
zur Bereitstellung eines Namespace für die gruppierten Elemente. Da es sich bei einem Paket um
einen Namespace handelt, kann ein Paket einzelne Elemente oder alle Elemente anderer Pakete
importieren. Pakete können auch mit anderen Paketen zusammengeführt werden.
Profil
Fügt das Profil-Element ein, einen bestimmten Pakettyp, der auf andere Pakete angewendet
werden kann.
Das Profile-Paket dient zum Erweitern des UML-Metamodells. Das primäre Erweiterungskonstrukt
ist das Stereotyp, welches selbst Teil des Profils ist. Profile müssen immer in Beziehung zu
einem Referenz-Metamodell wie z.B. UML stehen und können nicht alleine stehen.
Abhängigkeit
Fügt das Abhängigkeits-Element ein, welches eine Bereitsteller/Client-Beziehung zwischen
Modellierungselementen - in diesem Fall Paketen oder Profilen anzeigt.
Paketimport
Fügt eine <<import>> Beziehung ein, welche anzeigt, dass die Elemente des inkludierten Pakets
in das inkludierende Paket importiert werden. Der Namespace des inkludierenden Pakets erhält
Zugriff auf den inkludierten Namespace; der Namespace des inkludierten Pakets ist nicht
betroffen.
Anmerkung: Elemente, die in einem Paket als "privat" definiert sind, können nicht
zusammengeführt oder importiert werden.
Paketmerge
Fügt eine <<merge>> Beziehung ein, welche anzeigt, dass die Elemente des
zusammengeführten (Quell)-Pakets einschließlich aller in das zusammengeführte (Quell)-Paket
importierten Inhalte in das zusammenführende (Ziel)-Paket importiert werden.
Wenn dasselbe Element im Zielpaket bereits vorhanden ist, werden die Definitionen dieser
Elemente um die Definitionen aus dem Zielpaket erweitert. Aktualisierte oder hinzugefügte
Elemente werden durch eine Generalisierungsbeziehung zurück zum Quellpaket gekennzeichnet.
Anmerkung: Elemente, die in einem Paket als "privat" definiert sind, können nicht
zusammengeführt oder importiert werden.
Profilzuweisung
Fügt eine Profilzuweisung ein, die anzeigt, welche Profile einem Paket zugewiesen wurden.
Hierbei handelt es sich um eine Art des Paketimports, der festlegt, dass ein Profil auf ein Paket
angewendet wird.
Das Profil erweitert das Paket, dem es zugewiesen wurde. Bei Zuweisung eines Profils mit Hilfe
des Symbols "Profilzuweisung" stehen alle Stereotype, die Teil dieses Profils sind, auch dem
Paket zur Verfügung.
Profilnamen werden als strichlierte Pfeile vom Paket zum zugewiesenen Profil mit dem
Schlüsselwort <<apply>> angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
309
Generieren von Paketdiagrammen beim Importieren von Code oder Binärdateien
Sie können bei Import von Quellcode oder Binärdateien in ein UModel-Projekt (siehe Importieren
von Quellcode in Projekte und Importieren von Java-, C#- und VB-Binärdateien) Paketdiagramme
generieren. Nehmen Sie im Importassistenten folgende Einstellungen vor:
1) Im Dialogfeld "Quellprojekt importieren", "Binärtypen importieren" bzw. "Quellverzeichnis
importieren" muss das Kontrollkästchen Diagrammgenerierung aktivieren aktiviert sein.
Dialogfeld "Quellproj ekt importieren"
2) Im Dialogfeld "Generierung von Paketabhängigkeitsdiagrammen"muss die Option Diagramm
generieren aktiviert sein.
© 2016 Altova GmbH
Altova UModel 2017
310
UML-Diagramme
Strukturdiagramme
Dialogfeld "Generierung von Paketabhängigkeitsdiagrammen"
Nach Fertigstellung des Imports stehen die generierten Klassendiagramme in der DiagrammStruktur unter "Klassendiagramme" zur Verfügung.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
311
Diagramm-Struktur
© 2016 Altova GmbH
Altova UModel 2017
312
UML-Diagramme
9.2.7
Profildiagramm und Stereotype
Altova Website:
Strukturdiagramme
UML-Profildiagramme
In UML-Profildiagrammen können Sie benutzerdefinierte Stereotype, Eigenschaftswerte und
Constraints in einem bestimmten Diagramm definieren.
Profile und Stereotype dienen zur Erweiterung des UML-Metamodells. Das primäre
Erweiterungskonstrukt ist das Stereotyp, welches selbst Teil des Profils ist. Profile müssen
immer mit einem Referenzmetamodell wie z.B. UML verknüpft sein. Sie können nicht alleine
vorkommen. UModel unterstützt nun das Profildiagramm, in dem Sie Ihre eigenen Stereotype
definieren können.
Bei Erstellung neuer UModel-Projekte über den Menüeintrag Projekt | Unterprojekt inkludieren
muss die Datei Java Profile.ump (C# Profile.ump oder VB Profile.ump) angewendet werden.
Dieses Profil liefert die Java-Datentypen und Stereotype und wird für die Erstellung von Code für
das Round-Trip Engineering benötigt.
In den folgenden Abschnitten werden folgende Punkte beschrieben:
Hinzufügen von Stereotypen und Definieren von Eigenschaftswerten
Stereotype und Enumerationen
Benutzerdefinierte Stereotypstile
In der Datei Bank_CSharp.ump (im Ordner ...\UModelExamples) sehen Sie ein Beispiel dafür.
Das C#-Profil wurde auf das Paket "BankView" angewendet.
Profile sind bestimmte Arten von Paketen, die auf andere Pakete angewendet werden.
Stereotype sind bestimmte Metaklassen, die Standardklassen erweitern.
"Eigenschaftswerte" sind Werte von Stereotypattributen.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
313
Eine Profilzuweisung zeigt an, welche Profile auf ein Paket angewendet wurden. Es handelt sich
hierbei um eine Art von Paketimport, der angibt, dass ein Profil auf ein Paket angewendet wird.
Das Profil erweitert das Paket, auf das es angewendet wurde. Wenn Sie ein Profil mit Hilfe des
Symbols "Profilzuweisung"
anwenden, bedeutet dies, dass alle Stereotype, die Teil des
Profils sind, ebenfalls im Paket zur Verfügung stehen.
Profilzuweisungen werden in Form strichlierter Pfeile dargestellt, die vom Paket zum
zugewiesenen Profil weisen und mit dem Schlüsselwort <<apply>> versehen sind.
Stereotype:
Ein Stereotyp definiert, wie eine bestehende Metaklasse erweitert werden kann. Es handelt sich
hierbei um eine Art von Klasse, die Klassen durch Erweiterungen erweitert. Stereotype können
nur in Profilen erstellt werden. Stereotype werden als Klassen, in Klassendiagrammen dargestellt
und werden zusätzlich mit dem Schlüsselwort <<stereotype>> oberhalb des Klassennamens
versehen.
Stereotype können Eigenschaften haben, die als "Eigenschaftsdefinition" bezeichnet
werden.
Wenn das Stereotyp auf ein Modellelement angewendet wird, werden die Werte der
Eigenschaften als "Eigenschaftswerte" bezeichnet.
Bei Anwendung von Steretypen, die Eigenschaften enthalten, werden die
Eigenschaftswerte automatisch in einem Comment-Element (siehe unten) angezeigt.
Nähere Informationen zum Anpassen der Eigenschaftswerteansicht finden Sie unter
Eigenschaftswerte.
Stereotype haben Ihre eigene Stilfamilie.
Wenn das Attribut vom Typ "Enumeration" ist, erscheint ein Popup-Menü, aus dem Sie
einen der vordefinierten Werte auswählen können. Sie können auch den jeweiligen Wert
auf dem Register "Eigenschaften" eingeben/auswählen, z.B. <<GetAccessor>>
Sichtbarkeit = public, protected usw.
© 2016 Altova GmbH
Altova UModel 2017
314
UML-Diagramme
Strukturdiagramme
Hinzufügen von Stereotypen und Definieren von Eigenschaftswerten
In diesem Abschnitt wird die Datei Bank_MultiLanguage.ump aus dem Ordner ...
\UModelExamples verwendet.
Erstellen eines Profildiagramms und eines Stereotyps
1. Erstellen Sie in der Modellstrukturansicht ein neues Profil. Klicken Sie z.B. mit der
rechten Maustaste auf das Root-Paket und wählen Sie den Befehl Neues Element |
Profil und nennen Sie es "MyProfile".
2. Klicken Sie mit der rechten Maustaste in der Modell-Struktur auf das Paket MyProfile
und wählen Sie den Befehl Neues Diagramm | Profildiagramm. Daraufhin wird das
Profildiagramm zum ausgewählten Paket hinzugefügt.
3. Ziehen Sie das neu erstellte Profil "MyProfile" aus der Modellstruktur in das neue
Klassendiagramm.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
315
4. Ziehen Sie auch das Paket DesignView in das neue Klassendiagramm.
5. Klicken Sie in der Symbolleiste auf die Schaltfläche "Profilzuweisungen"
, wählen
Sie das Paket "DesignView" und ziehen Sie den Konnektor auf das Paket "MyProfile".
Auf diese Art können die in diesem Profil (MyProfile) definierten Stereotype im Paket
DesignView oder einem seiner Unterpakete verwendet werden.
6. Klicken Sie in der Symbolleiste auf die Schaltfläche "Stereotyp"
Stereotyp "class", z.B. MyKeyValuePair, ein.
und fügen Sie ein
7. Drücken Sie F7, um ein Attribut zum Stereotyp hinzuzufügen, z.B. MyKey1. Fügen Sie
auf dieselbe Art MyKey2 hinzu.
Damit ist die Definition des Stereotyps für den Moment abgeschlossen. Wir können das
© 2016 Altova GmbH
Altova UModel 2017
316
UML-Diagramme
Strukturdiagramme
Steretyp nun verwenden/zuweisen, wenn wir ein Attribut zu einer Klasse hinzufügen, die
Teil des Pakets "BankView" ist.
Verwenden / Zuweisen von Stereotypen
1. Doppelklicken Sie in der Modellstruktur auf das Klassendiagramm "BankView Main".
Daraufhin wird das Klassendiagramm geöffnet und die Assoziationen zwischen den
verschiedenen Klassen werden angezeigt. Wir wollen nun ein Attribut zur Klasse
"BankView" hinzufügen und das zuvor definierte Stereotyp zuweisen/verwenden.
2. Klicken Sie auf die Klasse BankView und drücken Sie F7, um ein Attribut hinzuzufügen.
3. Mit Hilfe der Bildlaufleiste des Registers "Eigenschaften" können Sie zum unteren
Bereich der Liste scrollen. Beachten Sie, dass das Stereotyp MyKeyValuePair im
Listenfeld zur Verfügung steht.
4. Klicken Sie auf das Kontrollkästchen von MyKeyValuePair um das Stereotyp zu
aktivieren/anzuwenden. Die beiden Eigenschaftswerte MyKey1 und MyKey2 werden nun
unter dem Eintrag "Stereotyp" angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
317
5. Doppelklicken Sie in die entsprechenden Felder und geben Sie Werte ein.
Anzeigen von Eigenschaftswerten in einem Diagramm
1. Klicken Sie auf das Register "Stile", scrollen Sie zum Eintrag Eigenschaftswerte
anzeigen und wählen Sie den Eintrag alle.
Auf dem Diagrammregister werden die Eigenschaftswerte nun im Anmerkungselement
angezeigt. Wenn Sie im Anmerkungselement auf einen Wert doppelklicken, können Sie
ihn direkt bearbeiten.
Eigenschaftswerte anzeigen: in Bereich
© 2016 Altova GmbH
Altova UModel 2017
318
UML-Diagramme
Strukturdiagramme
Zeigt die Eigenschaftswerte in einem separaten Klassenbereich an.
Bitte beachten Sie:
Wenn Attribute oder Operationen über die Kontextmenüoption "Knoteninhalt ein-/
ausblenden" ausgeblendet werden, werden auch die Eigenschaftswerte zusammen mit
dem Modellierungselement ein- bzw. ausgeblendet.
Bei Assoziations-(Member) Ends können Stereotype durch Setzen der Option
MemberEnd-Stereotype anzeigen auf dem Register "Stile" auf "true" angezeigt
werden.
Nähere Informationen zur Anzeige von Eigenschaftswerten finden Sie unter Anzeige von
Eigenschaftswerten.
Stereotype und Enumerationen
UModel verfügt über eine effiziente Methode zum Auswählen von Enumerationswerten von
Stereotypen.
Klicken Sie auf das Diagrammregister, das die Stereotypdefinition enthält (also auf das zuvor
hinzugefügte Profildiagramm).
1. Klicken Sie in der Symbolleiste auf die Schaltfläche "Enumeration"
um eine
Enumeration in das Diagramm (mit dem zuvor definierten Stereotyp, z.B.
ProfileDiagram1) einzufügen.
2. Fügen Sie durch Drücken von UMSCHALT+F7 oder über das Kontextmenü
EnumerationLiterals zur Enumeration hinzu, z.B. die EnumerationLiterals Yes und No.
3. Klicken Sie auf das Stereotyp "class" und drücken Sie F7, um ein neues Attribut / eine
neue Eigenschaft z.B. Finished hinzuzufügen.
4. Wählen Sie auf dem Register "Eigenschaften" den Typ "MyEnum" aus.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
319
5. Wechseln Sie zurück zum Klassendiagramm BankView Main.
6. Im Element "Anmerkung" wird nun als Eigenschaftswert "Property Finished" angezeigt.
Wenn Sie auf den Eigenschaftswert "Finished" doppelklicken, werden die vordefinierten
Eigenschaftswerte in einem Popup-Fenster angezeigt. Klicken Sie auf eine der
Enumerationen, um sie auszuwählen.
Standardenumerationswerte
UModel gestattet Ihnen, Standardeigenschaftswerte zu definieren. Doppelklicken Sie beim
Hinzufügen eines Attributs zum Stereotyp in das Feld "Standardwert" und fügen Sie eine der
bestehenden Enumerationen als Standardwert hinzu.
© 2016 Altova GmbH
Altova UModel 2017
320
UML-Diagramme
Strukturdiagramme
In diesem Fall wird der Standardwert "Yes" eingegeben.
Wenn eine Eigenschaft zu einer Klasse hinzugefügt und der Typ MyEnum ausgewählt ist, wird
der Standardwert automatisch als Eigenschaftswert eingefügt, d.h. Finished = Yes.
Benutzerdefinierte Stereotypstile
Sie können nun auch benutzerdefinierte Stile für einzelne Stereotype erstellen. D.h. Sie können
spezielle Schriftarten, Farben usw. auf jene Klassen anwenden, die einer bestimmten
Stereotypart angehören.
So erstellen Sie benutzerdefinierte Stereotypstile:
1. Klicken Sie auf ein zuvor definiertes Stereotyp z.B. MyKeyValuePair im
Klassendiagramm.
2. Aktivieren Sie das Register "Stile" und wählen Sie anschließend in der Auswahlliste die
Option Stile von Elementen mit diesem Stereotyp aus.
3. Definieren Sie die Stile für dieses Stereotyp mit Hilfe der Optionen auf dem Register
"Stile", z.B. Farbverlauf Titel Ende = Aquamarin.
Wenn Sie auf die Stereotypklasse klicken, werden die Stereotypstile automatisch auf
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
321
dem Register "Stile" angezeigt.
4. Wechseln Sie zu einem anderen Klassendiagramm und fügen Sie einen neue Klasse ein.
5. Klicken Sie auf die Überschrift/den Titel der Klasse und aktivieren Sie das StereotypKontrollkästchen MyKeyValuePair.
Die neue Klasse hat nun die Stile, die dem Stereotyp zugewiesen wurden, z.B. einen
Hintergrundfarbverlauf in Aquamarin. Beachten Sie, dass die Stereotypstile nicht
angewendet werden, wenn das Stereotyp auf eine Eigenschaft oder Operation in der
Klasse angewendet wird.
6. Klicken Sie auf die neue Stereotypklasse im Diagramm und anschließend auf das
Register "Stile".
7. Wählen Sie in der Auswahlliste "Stile" den Eintrag "Angewandte Stereotypstile" aus.
Sie können nun eine Vorschau der für dieses Stereotyp definierten Stileinstellungen im
Fenster "Stile" anzeigen. Beachten Sie, dass Sie die Stileinstellungen hier nicht ändern
können. Dies muss in dem Klassendiagramm erfolgen, in dem das Stereotyp definiert
wurde.
Benutzerdefinierte Stereotypsymbole - Zuweisung
Sie können in UModel benutzerdefinierte Stereotypsymbole für benutzerdefinierte Stereotype
erstellen.
So erstellen Sie ein benutzerdefiniertes Stereotypsymbol:
1. Klicken Sie mit der rechten Maustaste auf das Root-Paket und wählen Sie den Befehl
Neues Element | Paket.
2. Geben Sie dem Paket den Namen MyPackage.
© 2016 Altova GmbH
Altova UModel 2017
322
UML-Diagramme
Strukturdiagramme
3. Klicken Sie mit der rechten Maustaste auf MyPackage und wählen Sie den Befehl Neues
Diagramm | Deployment-Diagramm.
Daraufhin wird in MyPackage ein Deployment-Diagramm erstellt.
4. Klicken Sie mit der rechten Maustaste in das Diagramm MyPackage und wählen Sie
Neu | Knoten.
Daraufhin wird ein Knotenobjekt zum Diagramm hinzugefügt.
5. Klicken Sie in der Modellstruktur mit der rechten Maustaste auf der Root-Paket und
wählen Sie den Befehl Neues Element | Profil.
6. Geben Sie dem Profil den Namen "MyProfile".
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
323
7. Klicken Sie mit der rechten Maustaste auf das Paket MyProfile und wählen Sie den
Befehl Neues Diagramm | Klassendiagramm.
Auswählen des Stereotypsymbols
1. Ziehen Sie die Ordner MyPackage und MyProfile aus der Modellstruktur in das
Klassendiagramm.
2. Klicken Sie in der Symbolleiste auf die Schaltfläche "Profilzuweisung"
Sie den Konnektor von MyPackage zu MyProfile.
3. Klicken Sie in der Symbolleiste auf die Schaltfläche "Stereotyp"
das Paket MyProfile um es einzufügen.
© 2016 Altova GmbH
und ziehen
und klicken Sie in
Altova UModel 2017
324
UML-Diagramme
Strukturdiagramme
Nehmen Sie auf dem Register "Eigenschaften" die folgenden Änderungen vor, während das
Stereotypelement aktiv ist:
4. Ändern Sie den Namen des Elements von Stereotyp1 in "Knoten".
5. Ändern Sie den Wert der Eigenschaft "Metaklasse" von Element in "Knoten".
6. Geben Sie im Feld "Symboldateiname" einen Pfad für das Bild ein, das Sie als
Stereotypsymbol verwenden wollen oder klicken Sie auf die Durchsuchen-Schaltfläche
um einen Pfad auszuwählen z.B. c:\Documents and Settings\Me\My Documents\Altova
\UModel2011\UModelExamples\Bank-PC.bmp.
7. Wechseln Sie zurück zum Deployment-Diagramm, indem Sie auf das Register
DeploymentDiagram1 klicken.
8. Klicken Sie im Diagramm auf das Element Node1.
9. Aktivieren Sie im Fenster "Eigenschaften" das Kontrollkästchen <Knoten>.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
Strukturdiagramme
325
Als Stereotypsymbol wird nun das der ausgewählten Bitmap-Grafik angezeigt.
Bitte beachten Sie:
Bei der Anzeige von benutzerdefinierten Symbolen ist die RGB-Farbe 82,82,82 die
transparente Hintergrundfarbe.
© 2016 Altova GmbH
Altova UModel 2017
326
UML-Diagramme
9.3
Zusätzliche Diagramme
UModel unterstützt nun den Import und die Generierung von W3C XML Schemas sowie das
Forward und Reverse Engineering bei der Codegenerierung.
XML-Schema
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
9.3.1
327
XML-Schema-Diagramme
Altova Website:
XML-Schemas in UML
In XML-Schema-Diagrammen werden Schemakomponenten in UML-Notation dargestellt. Globale
Elemente, d.h. Elemente, simpleTypes, complexTypes werden als Klassen oder Datentypen mit
den Attributen im Attributbereich angezeigt. Es gibt keine Operationen im Operationen-Bereich.
Zur Anzeige der Schemainformationen wird das Eigenschaftswert-Notiz Modellierungselement
verwendet.
Eine Tabelle über die Entsprechungen zwischen UML-Elementen und XML-Schema-Elementen/
Attributen finden Sie unter XML Schema von/zu UModel Elementen.
Bitte beachten Sie:
Ungültige XML-Schemas können nicht in UModel importiert werden. XML-Schemas
werden beim Import oder bei der Erstellung in UModel nicht validiert. XML-Schemas
werden bei der Überprüfung der Projektsyntax nicht berücksichtigt. Beim Import eines
XML-Schemas wird jedoch die Wohlgeformtheit des Schemas überprüft.
© 2016 Altova GmbH
Altova UModel 2017
328
UML-Diagramme
Importieren von XML-Schemas
So importieren Sie ein einzelnes XML-Schema:
1. Wählen Sie die Menüoption Projekt | XML-Schema-Datei importieren.
2. Stellen Sie sicher, dass das Kontrollkästchen Diagrammgenerierung aktivieren
aktiviert ist und klicken Sie zum Fortfahren auf "Weiter".
3. Definieren Sie die Inhaltsdiagrammoptionen in der Gruppe, die diese Überschrift trägt. Mit
der ersten Option wird für jedes globale Schema-Element ein separates Diagramm
erstellt.
4. Wählen sie die Bereiche aus, die in der Gruppe "Stile" in Klassendiagrammen angezeigt
werden sollen. Bei Auswahl der Option " Schemainformationen als Eigenschaftswerte
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
329
anzeigen" werden die Schemainformationen im Eigenschaftswert-NotizModellierungselement angezeigt.
5. Klicken Sie auf "Weiter", um das Paketabhängigkeitsdiagramm zu definieren.
6. Klicken Sie auf "Fertig stellen", um den XML-Schema-Import zu starten.
Das Schema/die Schemas werden in UModel importiert und alle Diagramme stehen in
Form von Registern zur Verfügung. In der Abbildung unten sehen Sie den Inhalt des
(complexType)-Diagramms EU-Address.
© 2016 Altova GmbH
Altova UModel 2017
330
UML-Diagramme
Bitte beachten Sie:
Es wurde ein neues Paket mit dem Namen "Alle Schemas" erstellt und als XSD Namespace Root
definiert. Anhand aller XSD Globals wird ein XML-Schema-Diagramm generiert, wobei die
Diagramme unter den jeweiligen Namespace-Paketen angelegt werden.
So importieren Sie mehrere XML-Schemas:
1. Wählen Sie die Menüoption Projekt | XML-Schemaverzeichnis importieren.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
331
2. Aktivieren Sie die Option "Alle Unterverzeichnisse verarbeiten", wenn auch Schemas aus
allen Unterverzeichnissen importiert werden sollen.
Der restliche Importvorgang erfolgt wie beim Import eines einzelnen XML-Schemas
(Beschreibung siehe oben).
Bitte beachten Sie:
Wenn ein XML-Schema andere Schemas inkludiert oder importiert, werden auch diese
Schemas automatisch importiert.
Anzeige von Eigenschaftswerten - Schemainformationen
Schemainformationen, die als Eigenschaftswerte im Anmerkungselement "Eigenschaftswert"
angezeigt werden, können auf dem Register "Stile" über den Eintrag "Eigenschaftswerte
anzeigen" oder durch Klicken auf das Symbol "Kompaktmodus ein-/ausschalten" rechts unten in
der Eigenschaftswert-Anmerkung konfiguriert werden. Hier können Sie zwischen den beiden unten
gezeigten Modi "Alle" und "Alle, leere ausblenden" wechseln.
Anmerkung:
Wenn Sie die Eigenschaftswerte vom Register Stile auswählen, werden die Einstellungen für die
© 2016 Altova GmbH
Altova UModel 2017
332
UML-Diagramme
Eigenschaftswerte projektweit vorgenommen. Wenn Sie mit der rechten Maustaste auf eine
Klasse klicken und Eigenschaftswerte | alle usw. auswählen, so wirkt sich die Einstellung nur auf
die einzeln markierten Klassen aus.
Eigenschaftswerte anzeigen: Alle
Zeigt die Eigenschaftswerte der Klasse sowie jene der dazugehörigen Attribute, Operationen usw.
an.
Eigenschaftswerte anzeigen: Alle, leere ausblenden
Zeigt nur diejenigen Eigenschaftswerte an, für die ein Wert vorhanden ist, z. B. fixed=true.
Eigenschaftswerte anzeigen: Element
Zeigt die Eigenschaftswerte der Klasse an, nicht aber jene der dazugehörigen Attribute,
Operationen usw.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
333
Eigenschaftswerte anzeigen: Element, leere ausblenden
Zeigt nur die Eigenschaftswerte einer Klasse an, jedoch ohne die dazugehörigen Attribute, für die
ein Wert vorhanden ist, z.B. id=123
Eigenschaftswerte anzeigen: im Bereich
Zeigt die Eigenschaftswerte in einem separaten Klassenbereich an.
Eigenschaftswerte anzeigen: in Bereich, leere ausblenden
Zeigt nur diejenigen Eigenschaftswerte einer Klasse - ohne die dazugehörigen Attribute - an, zu
denen ein Wert existiert.
XML-Schema-Annotation:
Beachte Sie bitte, dass beim Import eines XML-Schemas nur die erste Annotation eines complexoder simpleType im Fenster "Dokumentation" angezeigt wird.
© 2016 Altova GmbH
Altova UModel 2017
334
UML-Diagramme
Einfügen von XML-Schema-Elementen
1. Klicken Sie in der Symbolleiste auf das jeweilige XML-Schema-Diagramm-Symbol
2. Klicken Sie in das XML-Schema-Diagramm, um das Element einzufügen.
Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und auf das Diagrammregister
klicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
Ziehen bestehender Elemente in das XML-Schema-Diagramm:
Die meisten Elemente, die in anderen Diagrammen vorkommen, können in ein bestehendes XMLSchema-Diagramm eingefügt werden.
2. Ziehen Sie das/die Element(e) in das XML-Schema-Diagramm
Anmerkung: Sie können zum Einfügen von Elementen auch die Befehle "Kopieren" und
"Nur in Diagramm einfügen" verwenden.
Bitte beachten Sie:
Beide oben beschriebenen Methoden lassen sich auf jedes beliebige XML-Schema-Element
anwenden, das in die Diagramm eingefügt werden kann.
XSD Target Namespace
Fügt den Target Namespace für das Schema ein oder definiert ihn. Der XSD Target Namespace
muss einem XSD Namespace Root-Paket angehören.
XSD-Schema
Fügt ein XML-Schema ein oder definiert es. Das XSD-Schema muss einem XSD Target
Namespace-Paket angehören.
Element (global)
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
335
Fügt ein globales Element in das Diagramm ein. Beachten Sie: Auch die Eigenschaft wird
automatisch im Attribut-Bereich erstellt.
So definieren Sie die Datentyp-Eigenschaft:
1. Doppelklicken Sie auf die Eigenschaft und platzieren Sie den Cursor am Ende der Zeile.
2. Geben Sie einen Doppelpunkt ":" ein und wählen Sie im Popup-Dialogfeld den Datentyp aus,
z.B. String.
Erstellen eines "Content Model", das aus einem complexTyp mit
obligatorischen Elementen besteht:
Hierbei werden ein complexType-Element, ein Sequenz-Element/Kompositor und drei Elemente
eingefügt.
1. Klicken Sie auf das Symbol "XSD ComplexType"
und anschließend in das
Diagramm, um das Element einzufügen.
2. Doppelklicken Sie auf den Namen und ändern Sie ihn in "Address".
© 2016 Altova GmbH
Altova UModel 2017
336
UML-Diagramme
3. Rechtsklicken Sie auf "Address" und wählen Sie Neu | XSD Sequence.
4. Klicken Sie im Attribut-Bereich auf das Attribut _sequence:mg_sequence und ziehen
Sie es ins Diagramm.
Daraufhin wird an der Position, an der Sie die Maustaste loslassen, ein Sequenz
Klassen/Kompositor erstellt.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
337
5. Rechtsklicken Sie auf die Sequenzklasse und wählen Sie Neu | XSD Element (local).
Daraufhin wird ein neues Eigenschaftselement hinzugefügt.
6. Doppelklicken Sie auf die Eigenschaft, geben Sie den Elementnamen ein, z.B. Name,
fügen Sie einen Doppelpunkt ":" hinzu und geben Sie als Datentyp "string" ein.
7. Gehen Sie für die zwei weiteren Elemente ebenso vor und geben Sie ihnen z.B. die
Namen "Street" und "City".
8. Klicken Sie auf die Eigenschaft "Name" und ziehen Sie sie ins Diagramm.
Erstellen und Generieren eines XML-Schemas
Im Allgemeinen wird ein Schema importiert, in UModel bearbeitet und anschließend werden die
Änderungen ausgegeben. Sie können ein Schema aber auch von Grund auf neu erstellen. Dies
soll hier jedoch nur in groben Zügen beschrieben werden.
Erstellen eines neuen Schemas in UModel:
1. Erstellen Sie in der Modell-Struktur ein neues Paket, z.B. MY-Schemas.
© 2016 Altova GmbH
Altova UModel 2017
338
UML-Diagramme
2. Rechtsklicken Sie auf das neue Paket und wählen Sie die Menüoption Code
Engineering | Als XSD Namespace Root definieren.
Sie werden gefragt, ob Sie das XSD-Profil zuweisen möchten, wenn es sich hierbei um
die erste XSD Namespace Root im Projekt handelt.
3. Klicken Sie auf OK, um das Profil zuzuweisen.
4. Rechtsklicken Sie auf das neue Paket und wählen Sie den Befehl Neues Element |
Paket.
5. Doppelklicken Sie in das Namensfeld des Pakets und ändern Sie es in den gewünschten
Namespace, z.B. http://www.my-ns.com.
6. Klicken Sei auf dem Register "Eigenschaften" auf das Kontrollkästchen
<<namespace>>, um diesen als den Target Namespace zu definieren.
7. Rechtsklicken Sie auf das Namespace-Paket und wählen Sie den Befehl Neues
Diagramm | XML-Schema-Diagramm.
Sie werden gefragt, ob Sie das Schema-Diagramm zu einem neuen XSD-Schema
hinzufügen möchten.
8. Klicken Sie auf "Ja", um das neue Diagramm hinzuzufügen.
Sie können nun mit Hilfe der XML-Schema-Symbolleiste Ihr Schema erstellen.
Generieren des XML-Schemas:
1. Ziehen Sie das XSD-Schema auf eine Komponente, um eine Komponentenrealisierung zu
erstellen.
2. Stellen Sie sicher, dass als Codesprache der Komponente XSD1.0 eingestellt ist und
geben Sie einen Pfad ein, unter dem das generierte Schema gespeichert werden soll,
z.B. C:\schemacode\MySchema.xsd.
Altova UModel 2017
© 2016 Altova GmbH
UML-Diagramme
339
3. Wählen Sie die Menüoption Projekt | Überschreibe Programmcode von UModelProjekt, und klicken Sie auf OK, um das Schema zu generieren.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 10
Austausch von Metadaten zwischen XMI und XML
342
10
Altova Website:
Austausch von UModel-Projekten über XMI
UModel unterstützt den Export und Import von XMI 2.4 für UML 2.0 / 2.1 / 2.1.1 und 2.1.2, 2.2,
2.3, 2.4. Verwenden Sie die Funktion für den Export in XMI nicht zum Archivieren Ihrer UModelProjekte. Archivieren Sie statt dessen die *.ump-Projektdateien.
Wählen Sie den Menüeintrag Datei | In XMI-Datei exportieren, um eine XMI-Datei aus dem
UModel-Projekt zu erstellen und Datei | Aus XMI-Datei importieren, um eine zuvor generierte
XMI-Datei zu importieren.
Über das Dialogfeld "XMI-Export" können Sie das gewünschte XMI-Format auswählen - XMI für
UML 2.0/2.1.1. Beim Export inkludierte Dateien werden selbst solche, die als "Durch Referenz"
definiert werden, ebenfalls exportiert.
Bitte beachten Sie:
Wenn Sie bereits generierten XMI-Code wieder in UModel importieren möchten, stellen Sie
sicher, dass Sie das Kontrollkästchen "UModel-Erweiterungen exportieren" aktiviert haben.
Pretty-Print XMI-Ausgabe
Mit dieser Option wird die XMI-Datei mit der richtigen Einrückung der XML-Tags und mit
Zeilenschaltungen ausgegeben.
UUIDs exportieren
In XMI sind drei Elementidentifikationensversionen definiert: IDs, UUIDs und Labels.
IDs sind innerhalb des XMI-Dokuments eindeutig und werden von den meisten UML-Tools
unterstützt. UModel exportiert standardmäßig diese ID-Typen, d.h. keines der
Kontrollkästchen muss aktiviert werden.
UUID sind Universally Unique Identifiers und bieten eine Methode, um jedem Element
eine GUID (Global Unique Identification) zuzuweisen, d.h. UUIDs sind nicht auf bestimmte
XMI-Dokumente beschränkt. UUIDs werden durch Auswahl des Kontrollkästchens "UUIDs
exportieren" generiert.
UUIDs werden im Standardformat UUID/GUID gespeichert (z.B. "6B29FC40-CA47-1067-
Altova UModel 2017
© 2016 Altova GmbH
343
B31D-00DD010662DA", "550e8400-e29b-41d4-a716-446655440000",...)
Labels werden von UModel nicht unterstützt.
Bitte beachten Sie:
Beim XMI-Importvorgang werden automatisch beide ID-Typen unterstützt.
UModel-Erweiterungen exportieren
In XMI ist ein "Erweiterungsmechanismus" definiert, mit Hilfe dessen jede Applikation ihre
toolspezifischen Erweiterungen zur UML-Spezifikation exportieren kann. Andere UML-Tools
können nur die Standard-UML-Daten importieren (die UModel-Erweiterungen werden ignoriert).
Diese UModel-Erweiterungsdaten stehen nur bei Import in UModel zur Verfügung.
Daten wie z.B. die Dateinamen von Klassen oder Elementfarben sind nicht Teil der UMLSpezifikation und müssen daher in XMI gelöscht oder unter "Extensions" gespeichert werden.
Wenn sie als Erweiterungen exportiert wurden und wieder importiert werden, werden alle
Dateinamen und Farben, wie definiert, importiert. Wenn für den Export keine Erweiterungen
verwendet werden, gehen diese UModel-spezifischen Daten verloren.
Beim Import eines XMI-Dokuments wird das Format automatisch ermittelt und das Modell
generiert.
Diagramme exportieren
Exportiert UModel-Diagramme als "Erweiterungen" in die XMI-Datei. Die Option "UModelErweiterungen exportieren" muss aktiv sein, damit das Diagramm als Erweiterung gespeichert
werden kann.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 11
UModel-Unterstützung für die Arbeit im Team
346
11
UModel-Projekte können in mehrere Unterprojekte aufgeteilt werden, sodass mehrere Entwickler
unterschiedliche Teile eines einzigen Projekts gleichzeitig bearbeiten können. Die einzelnen
Unterprojekte können zu einem Versionskontrollsystem hinzugefügt werden.
Das Projekt der obersten Ebene, also das Projekt, von dem aus die Unterprojekte inkludiert
werden können, wird als das Hauptprojekt bezeichnet. Unterprojekte werden auf Paketebene in
Form einzelner UModel-Projektdateien erstellt und haben die Erweiterung *.ump.
Unterprojekte können auf zwei verschiedene Arten erstellt/inkludiert werden:
als vom Hauptprojekt aus und auf Unterprojektebene editierbare Projekte
als Projekte, die vom Hauptprojekt aus schreibgeschützt sind, d.h. nur auf
Unterprojektebene bearbeitet werden können.
Unterprojekte können beliebig strukturiert werden, in einer flachen oder einer hierarchischen
Struktur oder in Form einer Kombination aus beiden. Dadurch kann praktisch jedes Paket eines
Hauptprojekts in schreibgeschützte/editierbare Unterprojektdateien aufgeteilt werden.
Beim Code Engineering werden alle untergeordneten Komponenten eines Unterprojekts
berücksichtigt. Es besteht kein Unterschied zwischen einer einzelnen Projektdatei oder einer
Projektdatei, die aus mehreren editierbaren Unterprojekten besteht.
Dies gilt auch für UML-Diagramme. Auch diese Diagramme können auf der Haupt- oder
Unterprojektebene bearbeitet werden.
Altova UModel 2017
© 2016 Altova GmbH
Erstellen und Bearbeiten von Unterprojektdateien
347
11.1 Erstellen und Bearbeiten von Unterprojektdateien
Im hier beschriebenen Beispiel wird gezeigt, wie das Projekt Bank_MultiLanguage.ump in
mehrere Unterprojekte aufgeteilt wurde.
Bitte beachten Sie:
UModel gestattet Ihnen, Pakete und etwaige darin enthaltene UML-Diagramme freizugeben und in
mehreren Projekten zu nutzen. Pakete können in andere Projekte entweder durch eine Referenz
oder als Kopie inkludiert werden. Nähere Informationen dazu finden Sie unter Freigeben von
Paketen und Diagrammen.
So erstellen Sie eine Unterprojektdatei
Unterprojektdateien können jederzeit von einer Haupt- oder Unterprojektdatei abgespalten werden.
1. Klicken Sie mit der rechten Maustaste auf ein oder mehrere Pakete, z.B. das Paket
Banking access und wählen Sie den Befehl Unterprojekt | Neues Unterprojekt
erstellen.
© 2016 Altova GmbH
Altova UModel 2017
348
2. Klicken Sie auf die Schaltfläche "Durchsuchen" und wählen Sie das Unterverzeichnis
\Bank_MultiLanguage_Java aus.
3. Aktivieren Sie das Optionsfeld "Editierbar", damit das Unterprojekt vom Hauptprojekt aus
bearbeitet werden kann. (Wenn Sie "Schreibgeschützt" auswählen, kann es im
Hauptprojekt nicht bearbeitet werden.) Klicken Sie anschließend auf OK.
Der Name der Unterprojektdatei wird in eckigen Klammern neben dem Paketnamen
angezeigt und die Datei Banking access.ump wird in den Ordner UModelExamples
\Bank_MultiLanguage_Java platziert.
Auf dieselbe Weise wird ein Unterprojekt des Ordners BankView erstellt. Die Datei
BankView.ump wird im Ordner ...\UModelExamples\Bank_MultiLanguage_Java\
gespeichert.
Altova UModel 2017
© 2016 Altova GmbH
349
Bitte beachten Sie:
Der Dateipfad des Unterprojekts kann jederzeit durch Rechtsklick auf das Unterprojekt
und Auswahl des Befehls Unterprojekt | Dateipfad bearbeiten geändert werden.
Öffnen und Bearbeiten von Unterprojektdateien
Nachdem Sie eine Unterprojektdatei erstellt haben, kann die erzeugte *.ump Datei anschließend
geöffnet und als die UModel-Hauptprojektdatei bearbeitet werden. Dazu sollte es keine nicht
aufgelösten Referenzen auf andere Elemente geben. UModel führt bei Erstellung eines
Unterprojekts anhand des Hauptprojekts und beim Speichern einer Datei automatisch eine
Überprüfung durch.
1. Klicken Sie mit der rechten Maustaste im Hauptprojekt auf das Unterprojektpaket (z.B.
Bank Server.ump) und wählen Sie den Befehl Projekt | Als Projekt öffnen.
Daraufhin wird eine weitere Instanz von UModel gestartet und das Unterprojekt wird als
Hauptprojekt geöffnet. Alle nicht aufgelösten Referenzen werden im Fenster "Meldungen"
angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
350
Wiederverwendung von Unterprojekten
Unterprojekte, die von einem Hauptprojekt abgespalten wurden, können in jedem beliebigen
anderen Hauptprojekt verwendet werden.
1. Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie den Befehl
Projekt | Unterprojekt inkludieren.
2. Klicken Sie auf die Schaltfläche "Durchsuchen" und wählen Sie die gewünschte .umpDatei aus, z.B. Banking access.ump.
Altova UModel 2017
© 2016 Altova GmbH
351
3. Wählen Sie aus, wie die Datei inkludiert werden soll; durch eine Referenz oder als Kopie.
Speichern von Projekten
Wenn Sie die Hauptprojektdatei speichern, werden auch alle editierbaren Unterprojektdateien
gespeichert, d.h. alle in den freigegebenen Paketen der Unterprojektdateien enthaltenen Daten
werden gespeichert.
Sie sollten daher außerhalb der freigegebenen/Unterprojektstruktur keine Daten (Komponenten)
erstellen/hinzufügen, wenn das Unterprojekt in einer Hauptprojektdatei als "editierbar" definiert ist.
Wenn es noch Daten außerhalb der Unterprojektstruktur gibt, wird im Fenster "Meldungen" eine
Warnmeldung angezeigt.
Speichern von Unterprojektdateien
Beim Speichern von Unterprojekten (von der Hauptprojektebene aus) werden alle Referenzen auf
gleichrangige und untergeordnete Unterprojekte berücksichtigt und gespeichert. Wenn z.B. zwei
gleichrangige Unterprojekte, nämlich sub1 und sub2 existieren und in sub1 Elemente aus sub2
verwendet werden, dann wird sub1 so gespeichert, dass darin automatisch auch Referenzen auf
sub2 enthalten sind.
Wenn sub1 als ein Hauptprojekt geöffnet wurde, so wird es als unabhängiges Projekt betrachtet
und kann ohne Referenz auf das eigentliche Hauptprojekt bearbeitet werden.
Wiedereingliedern von Unterprojekten in das Hauptprojekt
Zuvor definierte Unterprojekte können wieder zurück in das Hauptprojekt kopiert werden. Wenn
das Unterprojekt keine Diagramme enthält, so wird es sofort wieder eingegliedert. Falls das
Unterprojekt Diagramme enthält, wird das folgende Dialogfeld angezeigt:
1. Klicken Sie mit der rechten Maustaste auf das Unterprojekt und wählen Sie den Befehl
Unterprojekt | Als Kopie inkludieren.
Daraufhin wird das Dialogfeld "Unterprojekt inkludieren" geöffnet, in dem Sie die
Diagrammstile, die Sie beim Inkludieren des Unterprojekts verwenden möchten, definieren
können.
© 2016 Altova GmbH
Altova UModel 2017
352
2. Wählen Sie die gewünschte Stiloption aus und klicken Sie anschließend auf OK, um das
Projekt wieder zu inkludieren.
Altova UModel 2017
© 2016 Altova GmbH
Kapitel 12
Versionskontrolle
354
Versionskontrolle
12
Versionskontrolle
Die Versionskontrollunterstützung in UModel steht über die Microsoft Source Control Plug-in API
(vormals bekannt als MSSCCI API), Version 1.1, 1.2 sowie 1.3 zur Verfügung. Dadurch können
Sie Versionskontrollbefehle wie z.B. "Einchecken" oder "Auschecken" direkt über UModel an
praktisch jedem Versionskontrollsystem ausführen, das nativen Clients oder Drittanbieter-Clients
über das Microsoft Source Control Plug-in API die Verbindung zu UModel gestattet.
Als Versionskontrollsystemanbieter kann jedes kommerzielle oder nicht kommerzielle Plug-in,
das die Microsoft Source Control Plug-in API unterstützt und mit einem kompatiblen
Versionskontrollsystem verbunden werden kann, verwendet werden. Eine Liste von von Altova
getesteten Versionskontrollsystemen und Plug-ins finden Sie unter Unterstützte
Versionskontrollsysteme.
Installieren und Konfigurieren des Versionskontrollanbieters
Um die auf Ihrem System verfügbaren Versionskontrollsysteme anzuzeigen, gehen Sie
folgendermaßen vor:
1. Klicken Sie im Menü Extras auf Optionen.
2. Klicken Sie auf das Register Versionskontrolle.
Alle mit der Microsoft Source Code Control Plug-in API kompatiblen Versionskontroll-Plug-ins
werden in der Dropdown-Liste Aktuelles Versionskontroll-Plug-in angezeigt.
Wenn auf Ihrem System kein kompatibles Plug-in gefunden wurde, wird die folgende Meldung
angezeigt:
"Die Registrierung des installierten Versionskontrollproviders konnte nicht
gefunden werden oder ist unvollständig."
Bei einigen Versionskontrollsystemen wird das Versionskontroll-Plug-in nicht automatisch
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
355
installiert. In diesem Fall müssen Sie es gesondert installieren. Eine genauere Anleitung dazu
finden Sie in der Dokumentation zum jeweiligen Versionskontrollsystem. Ein Plug-in (Anbieter),
das mit der Microsoft Source Code Control Plug-in API kompatibel ist, sollte auf Ihrem
Betriebssystem unter dem folgenden Registrierdateieintrag zu finden sein:
HKEY_LOCAL_MACHINE\SOFTWARE\SourceCodeControlProvider\InstalledSCCProviders
Wenn das Plug-in korrekt installiert wurde, steht es automatisch in der Liste der Plug-ins in
UModel zur Verfügung.
Aufrufen der Versionskontrollbefehle
Die Versionskontrollbefehle stehen über das Menü Projekt | Versionskontrolle zur Verfügung.
Probleme im Zusammenhang mit den Ressourcen / der Geschwindigkeit
Bei sehr großen Versionskontrolldatenbanken kann die automatische Durchführung von
Statusaktualisierungen im Hintergrund etwas länger dauern.
Um schneller arbeiten zu können, können Sie versuchen, auf dem Register
"Versionskontrolle" (Aufruf über Extras | Optionen) das Feld "Statusaktualisierung im
Hintergrund alle xxx Sek." zu deaktivieren oder das Aktualisierungsintervall zu vergrößern.
Anmerkung: Die 64-Bit-Version Ihrer Altova-Applikation unterstützt automatisch alle in dieser
Dokumentation aufgelisteten 32-Bit-Versionskontrollsysteme. Bei Verwendung einer 64Bit-Altova-Applikation zusammen mit einem 32-Bit-Versionskontrollsystem ist die Option
Statusaktualisierung im Hintergrund alle xxx Sek automatisch deaktiviert und kann
nicht ausgewählt werden.
Vergleich mit Altova DiffDog
Sie können viele Versionskontrollsysteme (einschließlich Git und TortoiseSVN) für die
Verwendung mit Altova DiffDog als Vergleichstool konfigurieren. Nähere Informationen zu DiffDog
finden Sie unter http://www.altova.com/de/diffdog.html. Die Dokumentation zu DiffDog finden Sie
unter http://www.altova.com/de/documentation.html.
© 2016 Altova GmbH
Altova UModel 2017
356
Versionskontrolle
Einrichten der Versionskontrolle
12.1 Einrichten der Versionskontrolle
So richten Sie eine Versionskontrolle ein und stellen Dateien in einem UModel-Projekt unter eine
Versionskontrolle:
1. Installieren Sie ein Versionskontrollprogramm (siehe Unterstützte
Versionskontrollsysteme), falls noch keines installiert ist. Richten Sie die
Versionskontrolldatenbank (das Repository), in der Sie Ihre Arbeit speichern möchten,
ein.
2. Erstellen Sie einen Ordner für den lokalen Arbeitsbereich, der die Arbeitsdateien
enthalten soll, die unter Versionskontrolle gestellt werden sollen. Der Ordner, der alle Ihre
Arbeitsbereichordner und -Dateien enthält, wird als ihr lokaler Ordner und der Pfad zum
lokalen Ordner als der lokale Pfad bezeichnet. Der Ordner wird an einen bestimmten
Ordner im Repository gebunden.
3. Erstellen Sie in Ihrer Altova-Applikation einen Applikationsprojektordner, zu dem Sie die
unter Versionskontrolle zu stellenden Dateien hinzufügen müssen. Diese Gliederung der
Dateien in einem Applikationsprojekt ist abstrakt. Die Dateien in einem Projekt
referenzieren physische lokal (vorzugsweise in einem einzigen Ordner, falls nötig mit
Unterordnern) gespeicherte Dateien.
4. In der Datenbank des Versionskontrollsystems (die auch als Versionskontrolle oder
Repository bezeichnet wird) wird ein Ordner erstellt, der an den lokalen Ordner gebunden
ist. Dieser (als gebundener Ordner bezeichnete) Ordner repliziert die Struktur des lokalen
Ordners, sodass sich alle unter Versionskontrolle zu stellenden Dateien an der richtigen
Stelle im gebundenen Ordner befinden. Der gebundene Ordner wird normalerweise
erstellt, wenn Sie zum ersten Mal eine Datei oder ein Applikationsprojekt zur
Versionskontrolle hinzufügen.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
Unterstützte Versionskontrollsysteme
357
12.2 Unterstützte Versionskontrollsysteme
In der nachfolgenden Liste sind die von UModel unterstützten Versionskontrollsysteme
zusammen mit ihren entsprechenden Versionskontroll-Clients (SCCs) aufgelistet. Die Liste ist
alphabetisch nach Versionskontrollsystem geordnet.
Altova hat in UModel die Microsoft Source Control Plug-in API (Version 1.1, 1.2 und 1.3)
implementiert und die Unterstützung für die aufgelisteten Treiber und
Versionskontrollsysteme getestet. Aller Voraussicht nach wird UModel diese Produkte,
falls diese aktualisiert werden, weiterhin unterstützen.
Auch Versionskontroll-Clients, die nicht in der nachstehenden Liste erwähnt sind, die
aber die Microsoft Source Control Plug-in API implementieren, sollten ebenfalls mit
UModel funktionieren.
Versionskontrollsystem
Versionskontroll-Clients
AccuRev 4.7.0 Windows
AccuBridge for Microsoft SCC 2008.2
Bazaar 1.9 Windows
Aigenta Unified SCC 1.0.6
Borland StarTeam 2008
Borland StarTeam Cross-Platform Client 2008 R2
Codice Software Plastic SCM
Professional 2.7.127.10 (Server)
Codice Software Plastic SCM Professional
2.7.127.10 (SCC Plugin)
Collabnet Subversion 1.5.4
PushOK SVN SCC 1.5.1.1
PushOK SVN SCC x64 Version 1.6.3.1
TamTam SVN SCC 1.2.24
ComponentSoftware CS-RCS (PRO) 5.1 ComponentSoftware CS-RCS (PRO) 5.1
Dynamsoft SourceAnywhere for VSS
5.3.2 Standard/Professional Server
Dynamsoft SourceAnywhere für VSS 5.3.2 Client
Dynamsoft SourceAnywhere Hosted
Dynamsoft SourceAnywhere Hosted Client (22252)
Dynamsoft SourceAnywhere
Standalone 2.2 Server
Dynamsoft SourceAnywhere Standalone 2.2 Client
Git
PushOK GIT SCC Plug-in (siehe Versionskontrolle
mit Git )
IBM Rational ClearCase 7.0.1 (LT)
IBM Rational ClearCase 7.0.1 (LT)
March-Hare CVSNT 2.5 (2.5.03.2382)
March-Hare CVS Suite 2008
Mercurial 1.0.2 für Windows
© 2016 Altova GmbH
Jalindi Igloo 1.0.3
March-Hare CVS Suite Client 2008 (3321)
PushOK CVS SCC NT 2.1.2.5
PushOK CVS SCC x64 Version 2.2.0.4
TamTam CVS SCC 1.2.40
Sergey Antonov HgSCC 1.0.1
Altova UModel 2017
358
Versionskontrolle
Unterstützte Versionskontrollsysteme
Versionskontrollsystem
Versionskontroll-Clients
Microsoft SourceSafe 2005 mit CTP
Microsoft SourceSafe 2005 mit CTP
Microsoft Visual Studio Team System
2008/2010 Team Foundation Server
Microsoft Team Foundation Server 2008/2010
MSSCCI Provider
Perforce 2008 P4S 2008.1
Perforce P4V 2008.1
PureCM Server 2008/3a
PureCM Client 2008/3a
QSC Team Coherence Server 7.2.1.35
QSC Team Coherence Client 7.2.1.35
Reliable Software Code Co-Op 5.1a
Reliable Software Code Co-Op 5.1a
Seapine Surround SCM Client/Server für Seapine Surround SCM Client 2009.0.0
Windows 2009.0.0
Serena Dimensions Express/CM 10.1.3
für Win32 Server
Serena Dimensions 10.1.3 for Win32 Client
Softimage Alienbrain Server 8.1.0.7300
Softimage Alienbrain Essentials/Advanced Client
8.1.0.7300
SourceGear Fortress 1.1.4 Server
SourceGear Fortress 1.1.4 Client
SourceGear SourceOffsite Server 4.2.0
SourceGear SourceOffsite Client 4.2.0 (Windows)
SourceGear Vault 4.1.4 Server
SourceGear Vault 4.1.4 Client
VisualSVN Server 1.6
Altova UModel 2017
PushOK SVN SCC 1.5.1.1
PushOK SVN SCC x64 Version 1.6.3.1
TamTam SVN SCC 1.2.24
© 2016 Altova GmbH
Versionskontrolle
Versionskontrollbefehle
359
12.3 Versionskontrollbefehle
Die Versionskontrollbefehle von UModel werden in den folgenden Abschnitten anhand von Visual
SourceSafe angezeigt.
Die Beschreibung der im Folgenden beschriebenen Versionskontrollbefehle gelten für die
Standalone-Version von UModel. In der Visual Studio und der Eclipse Version von UModel
werden die Versionskontrollbefehle und Menübefehle verwendet, die in diesen IDEs zur Verfügung
stehen.
Aus Versionskontrolle öffnen
Versionskontrolle aktivieren
Aktuellste Version holen
Abrufen
Ordner abrufen
Auschecken
Einchecken
Auschecken rückgängig...
Zu Versionskontrolle hinzufügen
Von Versionskontrolle ausgliedern
Aus Versionskontrolle freigeben
Verlauf anzeigen
Unterschiede anzeigen
Eigenschaften anzeigen
Status aktualisieren
Versionskontrollmanager
Versionskontrolle wechseln
© 2016 Altova GmbH
Altova UModel 2017
360
Versionskontrolle
12.3.1 Aus Versionskontrolle öffnen
Mit dem Befehl "Aus Versionskontrolle öffnen" wird ein lokales Projekt anhand einer bestehenden
Versionskontrolldatenbank erstellt und unter Versionskontrolle - in diesem Fall SourceSafe gestellt.
1. Wählen Sie Projekt | Versionskontrolle | Aus Versionskontrolle öffnen. Daraufhin
wird das Anmeldedialogfeld geöffnet, in dem Sie Ihre Anmeldedaten eingeben, bevor Sie
fortfahren können. Daraufhin wird das Dialogfeld "Create local project from SourceSafe"
angezeigt.
2. Definieren Sie das Verzeichnis, das das neue lokale Projekt enthalten soll, z.B. c:\temp
\ssc. Dies wird zum neuen Arbeitsverzeichnis oder dem Auscheck-Ordner.
3. Wählen Sie das gewünschte SourceSafe-Projekt aus, z.B. Bank_CSharp. Wenn der hier
von Ihnen definierte Ordner noch nicht existiert, erscheint ein Dialogfeld, in dem Sie
aufgefordert werden, ihn zu erstellen.
4. Klicken Sie auf Ja, um das neue Verzeichnis zu erstellen. Das Dialogfeld "Öffnen" wird
angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
361
5. Wählen Sie die UModel-Projektdatei Bank_CSharp.ump aus und klicken Sie auf
"Öffnen".
Bank_CSharp.ump wird nun in UModel geöffnet und die Datei wird unter
Versionskontrolle gestellt. Angezeigt wird dies in der Modell-Struktur durch ein
Schlosssymbol über dem Root-Ordner. Der Root-Ordner repräsentiert sowohl die
Projektdatei als auch das Arbeitsverzeichnis für Versionskontrolloperationen.
Das Verzeichnis "BankCSharp" wurde lokal erstellt. Sie können nun mit diesen Dateien
normal arbeiten.
Anmerkung:
Informationen, wie Sie die beim Synchronisieren von Code generierten Codedateien
unter Versionskontrolle stellen, finden Sie unter: Hinzufügen zur Versionskontrolle
© 2016 Altova GmbH
Altova UModel 2017
362
Versionskontrolle
Symbole der Versionskontrolle:
oder
Das Vorhängeschloss-Symbol zeigt an, dass diese Datei oder dieser Ordner unter
Versionskontrolle steht, aber derzeit nicht ausgecheckt ist.
oder
Das rote Kontrollhäkchen zeigt an, dass diese Datei ausgecheckt ist, d.h. dass die UModelProjektdatei (oder Codedatei) zur Bearbeitung ausgecheckt wurde.
Das Sternchen in der Titelleiste der Applikation bedeutet, dass diese Datei verändert wurde. Beim
Schließen werden Sie aufgefordert, die Datei zu speichern.
oder
Das Personensymbol zeigt an, dass die Datei(en) von jemand anderem im Netzwerk oder von
Ihnen in ein anderes Arbeitsverzeichnis ausgecheckt wurde(n).
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
363
12.3.2 Versionskontrolle aktivieren
Mit Hilfe dieses Befehls können Sie die Versionskontrolle für ein UModel-Projekt aktivieren oder
deaktivieren. Der Befehl steht über das Projekt-Menü Projekt | Versionskontrolle |
Versionskontrolle aktivieren zur Verfügung. Bei Auswahl dieser Option für eine Datei oder
einen Ordner, wird die Versionskontrolle für das gesamte UModel-Projekt aktiviert/deaktiviert.
So aktivieren Sie die Versionskontrolle für ein Projekt:
1. Wählen Sie die Menüoption Projekt | Versionkontrolle und aktivieren Sie das
Kontrollkästchen Versionskontrolle aktivieren. Der vorherige Ein-/Auscheck-Status der
verschiedenen Dateien wird abgerufen und im Fenster "Modell-Struktur" angezeigt.
So deaktivieren Sie die Versionskontrolle für ein Projekt:
1. Wählen Sie die Menüoption Projekt | Versionkontrolle und deaktivieren Sie das
Kontrollkästchen Versionskontrolle aktivieren.
Sie werden nun gefragt, ob Sie die Binding-Informationen aus dem Projekt entfernen
möchten.
Um die Versionskontrolle provisorisch zu deaktivieren, wählen Sie Nein.
Um die Versionskontrolle für dieses Projekt permanent zu deaktivieren, wählen Sie Ja.
© 2016 Altova GmbH
Altova UModel 2017
364
Versionskontrolle
12.3.3 Aktuellste Version holen
Mit diesem Befehl wird die aktuellste Version der ausgewählten Datei(en) aus dem
Versionskontrollspeicher in das Arbeitsverzeichnis geholt. Die Dateien werden als
schreibgeschützte Dateien und nicht ausgecheckt abgerufen.
Wenn die betroffenen Dateien derzeit ausgecheckt sind, geschehen je nach Version des
Versionskontroll-Plugin verschiedene Dinge: Es geschieht nichts, neue Daten werden in Ihrer
lokalen Datei zusammengeführt oder Ihre Änderungen werden überschrieben.
Dieser Befehl funktioniert ähnlich wie der Befehl "Abrufen", doch wird das Dialogfeld
"Versionskontrolle - Abrufen" nicht angezeigt. Sie können daher keine erweiterten Abrufoptionen
definieren.
Beachten Sie, dass dieser Befehl bei Ausführung an einem Ordner automatisch eine rekursive
Operation "Aktuellste Version holen" ausführt, d.h. alle anderen Dateien, die sich in der
Pakethierarchie unterhalb der aktuellen befinden, sind davon betroffen.
So rufen Sie die neueste Version einer Datei ab:
1. Wählen Sie in der Modell-Struktur die Dateien aus, für die Sie die neueste Version holen
möchten.
2. Wählen Sie Projekt | Versionskontrolle | Aktuellste Version holen.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
365
12.3.4 Abrufen
Ruft eine schreibgeschützte Kopie der ausgewählten Dateien ab und platziert Sie in den
Arbeitsordner. Standardmäßig sind die Dateien nicht zur Bearbeitung ausgecheckt.
Verwenden von "Abrufen":
Wählen Sie in der Modell-Struktur die gewünschten Dateien aus.
Wählen Sie den Befehl Projekt | Versionskontrolle | Abrufen.
Geänderte Dateien überschreiben
Überschreibt lokal geänderte Dateien mit jenen aus der Versionskontrolldatenbank.
Alle auswählen
Wählt alle Dateien im Listenfeld aus.
Erweitert
Mit Hilfe dieser Option können Sie die Optionen Replace writable und Set timestamp in den
entsprechenden Auswahllisten auswählen.
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateien
entfernt.
© 2016 Altova GmbH
Altova UModel 2017
366
Versionskontrolle
12.3.5 Ordner abrufen
Ruft schreibgeschützte Kopien von Dateien in den ausgewählten Ordnern ab und platziert Sie in
den Arbeitsordner. Die Dateien werden standardmäßig nicht zur Bearbeitung ausgecheckt.
Verwenden von "Ordner abrufen":
Wählen Sie in der Modell-Struktur die gewünschten Dateien aus.
Wählen Sie den Befehl Projekt | Versionskontrolle | Abrufen.
Geänderte Dateien überschreiben
Überschreibt Dateien, die lokal geändert wurden, mit den Dateien aus der
Versionskontrolldatenbank.
Rekursiv (Struktur abrufen)
Ruft alle Dateien aus der Ordnerstruktur ab, die sich unterhalb des ausgewählten Ordners
befinden.
Erweitert
entfernt.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
367
12.3.6 Auschecken
Mit diesem Befehl checken Sie die aktuellste Version der ausgewählten Datei(en) aus und
platzieren beschreibbare Kopien davon in das Arbeitsverzeichnis. Die Dateien werden für andere
Benutzer als "ausgecheckt" markiert.
So checken Sie Dateien aus:
Wählen Sie die gewünschte Datei bzw. den gewünschten Ordner in der Modell-Struktur
aus.
Wählen Sie Projekt | Versionskontrolle | Auschecken.
Anmerkung:
Sie können die Anzahl der auszucheckenden Dateien ändern, indem Sie die einzelnen
Kontrollkästchen in der Liste der Dateien aktivieren.
Lokale Version auschecken:
Checkt nur die lokale Version der Dateien aus, nicht die aus der Versionskontrolldatenbank.
Folgende Objekte können ausgecheckt werden:
Einzelne Dateien - klicken Sie in der Modell-Struktur auf die Datei (oder mehrere Dateien
mittels Strg + Klick)
Projektordner - klicken Sie in der Modellstruktur auf den Ordner (oder mehrere Ordner
oder
Das rote Kontrollhäkchen zeigt an, dass die Datei/der Ordner ausgecheckt ist.#
Erweitert
© 2016 Altova GmbH
Altova UModel 2017
368
Versionskontrolle
entfernt.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
369
12.3.7 Einchecken
Mit diesem Befehl checken Sie zuvor ausgecheckte Dateien, d.h. Ihre lokal aktualisierten
Dateien, wieder ein und stellen die Dateien zurück in das Versionskontrollprojekt.
So checken Sie Dateien ein:
Wählen Sie die gewünschten Dateien in der Modell-Struktur aus.
Wählen Sie Projekt | Versionskontrolle | Einchecken.
Kürzel: Rechtsklicken Sie im Projektfenster auf ein ausgechecktes Objekt, und wählen Sie
"Einchecken" im Kontextmenü.
Anmerkung:
Sie können die Anzahl der einzucheckenden Dateien ändern, indem Sie die einzelnen
Folgende Objekte können eingecheckt werden:
Ordner - klicken Sie in der Modellstruktur auf die Ordner (mittels Strg + Klick)
oder
Das Vorhängeschloss-Symbol zeigt an, dass sich die Datei/der Ordner unter Versionskontrolle
befindet, aber derzeit nicht ausgecheckt ist.
© 2016 Altova GmbH
Altova UModel 2017
370
Versionskontrolle
12.3.8 Auschecken rückgängig...
Mit diesem Befehl werden Änderungen in zuvor ausgecheckten Dateien, also lokal aktualisierten
Dateien verworfen. Es werden die alten Dateien aus der Versionskontrolldatenbank beibehalten.
So machen Sie das Auschecken rückgängig..
Wählen Sie die Dateien in der Modellstruktur aus
Wählen Sie Projekt | Versionskontrolle | Auschecken rückgängig.
Anmerkung:
Sie können die Anzahl der Dateien ändern, indem Sie die einzelnen Kontrollkästchen in
der Liste der Dateien aktivieren.
Die Option "Auschecken rückgängig" kann auf die folgenden Dateien angewendet werden:
Ordner - klicken Sie in der Modellstruktur auf die Ordner (mittels Strg + Klick)
Erweitert
entfernt.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
371
12.3.9 Zu Versionskontrolle hinzufügen
Fügt die ausgewählten Dateien oder Ordner zur Versionskontrolldatenbank hinzu und stellt sie
unter Versionskontrolle. Wenn Sie ein neues UModel-Projekt hinzufügen, werden Sie aufgefordert
den Arbeitsbereichsordner und den Pfad anzugeben, unter dem das Projekt gespeichert werden
soll.
Nachdem Sie die UModel-Projektdatei (*.ump) unter Versionskontrolle gestellt haben, können Sie
anschließend die beim Code Engineering erzeugten Codedateien ebenfalls zur Versionskontrolle
hinzufügen. Bitte beachten Sie, dass die generierten Codedateien und das UModel-Projekt in das
oder unterhalb desselben SourceSafe-Arbeitsverzeichnisses gelegt werden müssen. Das in
diesem Abschnitt verwendete Arbeitsverzeichnis ist c:\temp\ssc\Bank_CSharp.
So fügen Sie mit UModel generierte Codedateien zur Versionskontrolle hinzu:
1. Erweitern Sie in der Modell-Struktur den Ordner "Component View" und navigieren Sie zur
Komponente "BankView".
2. Klicken Sie auf die BankView-Komponente und klicken Sie im Fenster "Eigenschaften"
auf das Durchsuchen-Symbol neben dem Feld "Verzeichnis".
3. Ändern Sie das Code Engineering-Verzeichnis z.B. in C:\Users\Altova\Documents
\UMODEL_WORK\codegen.
4. Wählen Sie den Menübefehl Projekt | Merge Programmcode aus UModel-Projekt.
5. Ändern Sie gegebenenfalls die Synchronisierungseinstellungen und bestätigen Sie mit
© 2016 Altova GmbH
Altova UModel 2017
372
Versionskontrolle
OK.
Im Meldungsfenster wird der Code aus dem Projektvorgang angezeigt.
Es erscheint ein Meldungsfeld, in dem Sie gefragt werden, ob Sie die neu erstellten
Dateien unter Versionskontrolle stellen möchten.
6. Klicken Sie auf Ja.
7. Daraufhin wird das Dialogfeld "Zu Versionskontrolle hinzufügen" geöffnet, in dem Sie die
Dateien auswählen können, die unter Versionskontrolle gestellt werden sollen.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
373
8. Klicken Sie auf OK, sobald Sie die gewünschten Dateien ausgewählt haben.
Neben den einzelnen unter Versionskontrolle gestellten Klassen/Dateiquellen erscheint
nun ein Vorhängeschloss-Symbol.
© 2016 Altova GmbH
Altova UModel 2017
374
Versionskontrolle
12.3.10 Von Versionskontrolle ausgliedern
Mit diesem Befehl entfernen Sie zuvor hinzugefügte Dateien aus dem Versionskontrollprodukt.
Diese Dateiarten werden zwar in der Modell-Struktur weiterhin angezeigt, können aber nicht
ausgecheckt werden. Mit Hilfe des Befehls "Zu Versionskontrolle hinzufügen" können Sie die
Dateien wieder unter Versionskontrolle stellen.
So entfernen Sie Dateien aus der Versionskontrolle:
Wählen Sie die gewünschten Dateien in der Modellstruktur aus
Wählen Sie Projekt | Versionskontrolle | Von Versionskontrolle ausgliedern.
Anmerkung:
Sie können die Anzahl der auszugliedernden Dateien ändern, indem Sie die einzelnen
Folgende Objekte könne aus der Versionskontrolle ausgegliedert werden:
Einzelne Dateien - klicken Sie auf die Datei (oder mehrere Dateien mittels Strg + Klick)
Ordner - klicken Sie auf das Ordnersymbol
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
375
12.3.11 Aus Versionskontrolle freigeben
Mit diesem Befehl werden Dateien aus anderen Projekten/Ordnern im ausgewählten Ordner in die
Versionskontrollspeicherschnittstelle in Form von freigegebenen Dateien einem Branch eingefügt.
Um dem Freigeben-Befehl verwenden zu können, müssen Sie für das Projekt, das Sie freigeben
möchten, Ein- und Auscheck-Rechte besitzen.
So geben Sie eine Datei aus der Versionskontrolle frei:
1. Wählen Sie den gewünschten Ordner in der Modellstruktur aus und wählen Sie den
Befehl Projekt | Versionskontrolle | Aus Versionskontrolle freigeben, z.B. die
Komponente BankView im Ordner Component View.
2. Wählen Sie im Listenfeld "Projekte" den Projektordner aus, der die Datei enthält.
3. Wählen Sie im Listenfeld "Files to share" die gewünschte Datei aus und klicken Sie auf
die Schaltfläche "Freigeben".
Die Datei wird nun aus der Liste "Files to share" entfernt.
4. Klicken Sie zum Fortfahren auf "Schließen".
Branch after share
Gibt die Datei frei und erstellt einen neuen Branch zum Erstellen einer separaten Version.
© 2016 Altova GmbH
Altova UModel 2017
376
Versionskontrolle
12.3.12 Verlauf anzeigen
Mit diesem Befehl zeigen Sie den Verlauf einer unter Versionskontrolle stehenden Datei an. Sie
können damit eine detaillierte Verlaufsliste anzeigen, genauere Verlaufsinformationen anzeigen,
einen Vergleich durchführen oder frühere Versionen der Datei abrufen.
So zeigen Sie den Verlauf einer Datei an:
1. Klicken Sie im Fenster "Modell-Struktur" auf die Datei, deren Verlauf Sie ansehen
möchten.
2. Wählen Sie die Menüoption Projekt | Versionskontrolle | Verlauf anzeigen.
Es erscheint ein Dialogfeld, in dem Sie nähere Informationen eingeben müssen.
3. Wählen Sie den gewünschten Eintrag und bestätigen Sie mit OK.
Dieses Dialogfeld bietet verschiedene Möglichkeiten, um bestimmte Versionen der
ausgewählten Datei zu vergleichen und abzurufen. Wenn Sie auf einen Eintrag in der
Liste doppelklicken, wird das Dialogfeld "Verlauf" für diese Datei geöffnet.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
377
Schließen
Schließt dieses Dialogfeld.
Ansicht
Öffnet ein weiteres Dialogfeld, in dem Sie die Art des Ansichtsprogramms auswählen
können, in dem Sie die Datei anzeigen möchten.
Details
Öffnet ein Dialogfeld, in dem Sie die Eigenschaften der gerade aktiven Datei sehen.
Abrufen
Damit können Sie eine der vorherigen Versionen der Datei aus der Versionsliste in das
Arbeitsverzeichnis holen.
Auschecken
Damit können Sie die neueste Version der Datei auschecken.
Diff
Öffnet das Dialogfeld Vergleichsoptionen, in dem Sie die Vergleichsoptionen zur Anzeige
der Unterschiede zwischen den beiden Dateiversionen definieren können.
Mit Hilfe von Strg + Klick können Sie zwei Dateiversionen in diesem Fenster markieren.
Klicken Sie anschließend auf Diff, um die Unterschiede zwischen den beiden Dateien
anzuzeigen.
Pin
Markiert eine Version der Datei bzw. hebt die Markierung auf. Damit können Sie die
Dateiversion definieren, die für den Dateivergleich verwendet werden soll.
Rollback
Führt ein Rollback für die ausgewählte Version der Datei durch.
Report
Generiert einen Verlaufsbericht, den Sie an den Drucken, die Datei oder die
Zwischenablage senden können.
Hilfe
Öffnet die Online-Hilfe des Versionskontrollanbieters für das Plugin.
© 2016 Altova GmbH
Altova UModel 2017
378
Versionskontrolle
12.3.13 Unterschiede anzeigen
Dieser Befehl ermöglicht die Anzeige von Unterschieden zwischen der in der VersionskontrollAblage befindlichen und der gleichnamigen Datei, die Sie ein-/ausgecheckt haben.
Wenn Sie eine der Dateien im Dialogfeld "Verlauf" mit einem Pin markiert haben, so wird diese
Datei im Textfeld "Vergleichen" verwenden. Sie können mit Hilfe der Durchsuchen-Schaltfläche 2
beliebige Dateien auswählen.
So zeigen Sie die Unterschiede zwischen zwei Dateien an:
1. Klicken Sie in der Modell-Struktur auf eine Datei.
2. Wählen Sie die Menüoption Projekt | Versionskontrolle | Unterschiede anzeigen.
Es erscheint ein Dialogfeld, in dem Sie weitere Informationen eingeben können.
3. Wählen Sie die gewünschten Einträge und bestätigen Sie mit OK.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
379
Die Unterschiede zwischen beiden Dateien werden in beiden Fenstern farblich markiert (in
diesem Beispiel wird MS Source-Safe verwendet).
© 2016 Altova GmbH
Altova UModel 2017
380
Versionskontrolle
12.3.14 Eigenschaften anzeigen
Mit diesem Befehl können Sie die Eigenschaften der ausgewählten Datei anzeigen. Die Anzeige
kann je nach verwendetem Versionskontrollprodukt unterschiedlich sein.
So zeigen Sie die Eigenschaften der aktuell ausgewählten Datei an:
Wählen Sie Projekt | Versionskontrolle | Eigenschaften.
Dieser Befehl kann jeweils nur an einer einzelnen Datei ausgeführt werden.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
381
12.3.15 Status aktualisieren
Mit diesem Befehl aktualisieren Sie den Status aller Projektdateien unabhängig von ihrem
derzeitigen Status.
© 2016 Altova GmbH
Altova UModel 2017
382
Versionskontrolle
12.3.16 Versionskontrollmanager
Mit diesem Befehl starten Sie die ursprüngliche Oberfläche Ihrer Versionskontroll-Software.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
383
12.3.17 Versionskontrolle wechseln
Über dieses Dialogfeld können Sie das Versionskontrollsystem-Binding wechseln. Klicken Sie
dazu zuerst auf die Schaltfläche "Bindung aufheben" und anschließend (optional) auf die
Schaltfläche "Auswählen", um ein neues Versionskontrollsystem auszuwählen. Klicken Sie
anschließend auf die Schaltfläche "Binden", um eine Bindung zu einem neuen Pfad in der
Speicherschnittstelle zu erstellen.
© 2016 Altova GmbH
Altova UModel 2017
384
Versionskontrolle
Versionskontrolle mit Git
12.4 Versionskontrolle mit Git
Unterstützung für Git als Versionskontrollsystem in UModel steht in Form eines DrittanbieterPlug-in namens GIT SCC Plug-in (http://www.pushok.com/software/git.html) zur Verfügung.
Zum Zeitpunkt der Verfassung dieser Dokumentation steht das GIT SCC Plug-in zum
Experimentieren zur Verfügung. Um das Plug-in verwenden zu können, müssen Sie beim
Plug-in-Anbieter registriert sein.
Mit Hilfe des GIT SCC Plug-in können Sie über die Befehle im Menü Projekt | Versionskontrolle
von UModel mit einem Git Repository arbeiten. Beachten Sie, dass die Befehle im Menü Projekt |
Versionskontrolle von UModel von der Microsoft Source Control Plug-in API (MSSCCI API), für
die eine andere Art von Design als von Git verwendet wird, bereitgestellt werden. Daher bildet das
Plug-in eine Zwischenschaltung zwischen "Visual Source Safe"-Funktionalitäten und GitFunktionalitäten. Das bedeutet einerseits, dass ein Befehl wie z.B. Aktuellste Version holen für
Git eventuell so nicht verwendet werden kann. Andererseits gibt es einige neue Git-spezifische
Aktionen, die über das Plug-in im Dialogfeld "Versionskontrollmanager" zur Verfügung gestellt
werden (Menü Projekt | Versionskontrolle | Versionskontrollmanager von UModel).
Das Dialogfeld "Versionskontrollmanager"
Andere häufig benötigte Versionskontrollbefehle stehen direkt im Menü Projekt |
Versionskontrolle zur Verfügung.
In den folgenden Abschnitten wird die Anfangskonfiguration des Plug-in sowie der grundlegende
Arbeitsablauf beschrieben:
Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-in
Hinzufügen eines Projekts zur Git-Versionskontrolle
Klonen eines Projekts anhand der Git-Versionskontrolle
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
385
12.4.1 Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-in
Um die Git-Versionskontrolle mit UModel zu aktivieren, muss zuerst das Drittanbieter-PushOK
GIT SCC Plug-in installiert, registriert und als Versionskontrollanbieter ausgewählt werden. Dies
geschieht folgendermaßen:
1. Laden Sie die Installationsdatei für das Plug-in von der Website des Anbieters (http://
www.pushok.com) herunter, starten Sie sie und befolgen Sie die
Installationsanweisungen.
2. Klicken Sie im Menü Projekt von UModel auf Versionskontrolle wechseln und
vergewissern Sie sich, dass PushOk GITSCC als Versionskontroll-Provider ausgewählt
ist. Wenn Push Ok GITSCC in der Liste der Provider nicht angezeigt wird, war die
Installation des Plug-in wahrscheinlich nicht erfolgreich. Lesen Sie in diesem Fall in der
Dokumentation des Anbieters nach, wie Sie das Problem lösen können.
3. Wenn ein Dialogfeld angezeigt wird, in dem Sie aufgefordert werden, das Plug-in zu
registrieren, klicken Sie auf Registrierung und befolgen Sie die Anweisungen des
Assistenten, um die Registrierung abzuschließen.
© 2016 Altova GmbH
Altova UModel 2017
386
Versionskontrolle
12.4.2 Hinzufügen eines Projekts zur Git-Versionskontrolle
Sie können UModel -Projekte als Git Repositories speichern. Die Struktur der zum Projekt
hinzugefügten Dateien oder Ordner würde anschließend der Struktur des Git Repository
entsprechen.
So fügen Sie ein Projekt zu einer Git-Versionskontrolle hinzu:
1. Stellen Sie sicher, dass das PushOK GIT SCC Plug-in als Versionskontrollanbieter
ausgewählt ist (siehe Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-in ).
2. Erstellen Sie ein neues leeres Projekt und vergewissern Sie sich, dass es keine
Validierungsfehler aufweist (d.h. dass bei Auswahl des Befehls Projekt | Projektsyntax
überprüfen keine Fehler oder Warnungen angezeigt werden).
3. Speichern Sie das Projekt in einem lokalen Ordner, z.B. unter C:\MyRepo\Project.ump.
4. Klicken Sie im Fenster der Modell-Struktur auf den Root-Node.
5. Klicken Sie im Menü Projekt unter Versionskontrolle auf Zu Versionskontrolle
hinzufügen.
6. Klicken Sie auf OK.
7. Geben Sie den Text Ihrer Commit-Meldung ein und klicken Sie auf OK.
Sie können jetzt Modellierungselemente (Diagramme, Klassen, Pakete usw.) zu Ihrem Projekt
hinzufügen. Beachten Sie, dass alle Projektdateien und -ordner sich unter dem Root-Ordner des
Projekts befinden müssen. Wenn das Projekt z.B. im Ordner C:\MyRepo angelegt wurde, so
sollten nur Dateien unter C:\MyRepo zur Projekt hinzugefügt werden. Wenn Sie versuchen,
Dateien, die sich außerhalb des Projekt-Root-Ordners befinden, zum Projekt hinzuzufügen, wird
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
387
eine Warnmeldung angezeigt:
© 2016 Altova GmbH
Altova UModel 2017
388
Versionskontrolle
12.4.3 Klonen eines Projekts anhand der Git-Versionskontrolle
Projekte, die bereits zur Git-Versionskontrolle hinzugefügt wurden (siehe Hinzufügen eines
Projekts zur Git-Versionskontrolle) können folgendermaßen über das Git Repository geöffnet
werden:
1. Vergewissern Sie sich, dass das PushOK GIT SCC Plug-in als VersionskontrollProvider ausgewählt ist (siehe Aktivieren der Git-Versionskontrolle mit dem Git SCC Plugin ).
2. Klicken Sie im Menü Projekt auf Versionskontrolle | Aus Versionskontrolle öffnen.
3. Geben Sie den Pfad oder die URL des Versionskontroll-Repository ein. Klicken Sie auf
Überprüfen, um die Gültigkeit des Pfads oder der URL zu überprüfen.
4. Geben Sie unter Lokaler Pfad den Pfad zu dem lokalen Ordner ein, in dem das Projekt
erstellt werden soll und klicken Sie auf Weiter. Wenn der lokale Ordner vorhanden ist,
wird (auch wenn er leer ist) das folgende Dialogfeld aufgerufen:
5. Klicken Sie zur Bestätigung auf Ja und anschließend auf Weiter.
Altova UModel 2017
© 2016 Altova GmbH
Versionskontrolle
389
6. Stellen Sie die restlichen Schritte des Assistenten fertig, wie für Ihr Projekt erforderlich.
7. Nach der Fertigstellung wird ein Durchsuchen-Dialogfeld angezeigt, in dem Sie
aufgefordert werden, das UModel-Projekt (*.ump)-Datei zu öffnen. Wählen Sie die
Projektdatei aus, um den Projektinhalt in UModel zu laden.
© 2016 Altova GmbH
Altova UModel 2017
Kapitel 13
UModel Diagrammsymbole
392
13
Der folgende Abschnitt enthält eine Kurzübersicht über die Symbole, die in den einzelnen
Modelldiagrammen zur Verfügung stehen.
Die Symbole sind in zwei Gruppen unterteilt:
Hinzufügen - Zeigt eine Liste von Elementen an, die zum Diagramm hinzugefügt werden
können.
Beziehung - Zeigt eine Liste von Beziehungsarten an, die zwischen Elementen im
Diagramm erstellt werden können.
Altova UModel 2017
© 2016 Altova GmbH
Aktivitätsdiagramm
393
13.1 Aktivitätsdiagramm
Hinzufügen
Aktion (Aufrufverhalten-Aktion)
Aktion (Aufrufoperationsaktion)
Ereignisannahmeaktion
Ereignisannahmeaktion (Zeitereignis)
Signalsendeaktion
Verzweigungsknoten (Verzweigung)
Verbindungsknoten
Startknoten
Endknoten für Kontrollflüsse
Parallelisierungsknoten (vertikal)
Inputpin
Outputpin
Wert-Pin
Objektknoten
Pufferknoten
Datenspeicherknoten
Aktivitätsbereich (horizontal)
Aktivitätsbereich (vertikal)
Aktivitätsbereich 2-dimensional
Kontrollfluss
Objektfluss
Ausnahme-Handler
Aktivität
Aktivitätsparameterknoten
StrukturierterAktivitätsknoten
Mengenverarbeitungsbereich
Erweiterungsknoten
Unterbrechungsbereich
Anmerkung
Anmerkung verknüpfen
© 2016 Altova GmbH
Altova UModel 2017
394
Klassendiagramm
13.2 Klassendiagramm
Beziehung:
Assoziation
Aggregation
Komposition
Assoziationsklasse
Abhängigkeit
Verwendung
Generalisierung
Hinzufügen:
Paket
Klasse
Schnittstelle
Enumeration
Datentyp
Primitivtyp
Profil
Stereotyp
Profilzuweisung
Instanzspezifikation
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
395
13.3 Kommunikationsdiagramm
Hinzufügen
Lebenslinie
Nachricht (Aufruf)
Nachricht (Antwort)
Nachricht (Löschung)
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
396
13.4 Kompositionsstrukturdiagramm
Hinzufügen
Kollaboration
Kollaborationsanwendung
Part (Eigenschaft)
Klasse
Schnittstelle
Port
Beziehung
Konnektor
Abhängigkeit (Rollenbindung)
Verwendung
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
Komponentendiagramm
397
13.5 Komponentendiagramm
Hinzufügen:
Paket
Schnittstelle
Klasse
Komponente
Artefakt
Beziehung:
Realisierung
Verwendung
Abhängigkeit
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
398
Deployment-Diagramm
13.6 Deployment-Diagramm
Hinzufügen:
Paket
Komponente
Artefakt
Knoten
Gerät
Ausführungsumgebung
Beziehung:
Manifestation
Deployment
Assoziation
Generalisierung
Abhängigkeit
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
399
13.7 Interaktionsübersichtsdiagramm
Hinzufügen
Aufrufverhalten - Aktion (Interaktion)
Aufrufverhalten - Aktion (Interaktionsverwendung)
Verzweigungsknoten
Verbindungsknoten
Startknoten
Parallelisierungsknoten (Horizontal)
Synchronisationsknoten (Horizontal)
Zeitdauerbedingung
Beziehung
Kontrollfluss
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
400
Objektdiagramm
13.8 Objektdiagramm
Beziehung:
Assoziation
Assoziationsklasse
Abhängigkeit
Verwendung
Generalisierung
Hinzufügen:
Paket
Klasse
Schnittstelle
Enumeration
Datentyp
Primitivtyp
Instanzspezifikation
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
Paketdiagramm
401
13.9 Paketdiagramm
Hinzufügen
Paket
Profil
Beziehung
Abhängigkeit
Paketimport
Paketmerge
Profilzuweisung
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
402
Profildiagramm
13.10 Profildiagramm
Hinzufügen
Profil
Stereotyp
Beziehung
Generalisierung
Profilzuweisung
Paketimport
Elementimport
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
Protokoll-Zustandsdiagramm
403
13.11 Protokoll-Zustandsdiagramm
Hinzufügen
Einfacher Zustand
Endzustand
Anfangszustand
Eintrittspunkt
Austrittspunkt
Entscheidung
Kreuzung
Beendung
Gabelung
Gabelung (horizontal)
Vereinigung
Vereinigung (horizontal)
Beziehung
Protocol Transition
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
404
Sequenzdiagramm
13.12 Sequenzdiagramm
Hinzufügen
Lebenslinie
Combined Fragment
Combined Fragment (Alternativen)
Combined Fragment (Loop)
Interaktionsverwendung
Gate
Zustandsinvariante
Zeitdauerbedingung
Zeitbedingung
Nachricht
Nachricht
Nachricht
Nachricht
(Aufruf)
(Antwort)
(Erstellung)
(Löschung)
Asynchrone Nachricht (Antwort)
Asynchrone Nachricht (Löschung)
Anmerkung
Keine Nachrichtennummerierung
Einfache Nachrichtennummerierung
Hierarchische Nachrichtennummerierung
Verschieben zusammengehöriger Nachrichten ein/aus
Automatische Erstellung von Antworten auf Nachrichten (Call) ein/aus
Altova UModel 2017
© 2016 Altova GmbH
Zustandsdiagramm
405
13.13 Zustandsdiagramm
Hinzufügen
Einfacher Zustand
Anfangszustand
Endzustand
Eintrittspunkt
Austrittspunkt
Entscheidung
Kreuzung
Beendung
Gabelung
Gabelung (horizontal)
Vereinigung
Vereinigung (horizontal)
Deep history
Shallow history
Beziehung
Transition
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
406
13.14 Zeitverlaufsdiagramm
Hinzufügen
Lebenslinie (Zustand/Bedingung)
Lebenslinie (Allgemeiner Wert)
Tick-Symbol
Zeitdauerbedingung
Zeitbedingung
Nachricht (Aufruf)
Nachricht (Antwort)
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
Use Case-Diagramm
407
13.15 Use Case-Diagramm
Hinzufügen:
Paket
Akteur
Use Case
Beziehung:
Assoziation
Generalisierung
Include
Extend
Anmerkung
© 2016 Altova GmbH
Altova UModel 2017
408
XML-Schema-Diagramm
13.16 XML-Schema-Diagramm
Hinzufügen
XSD Target Namespace
XSD Schema
XSD Element (global)
XSD Group
XSD ComplexType
XSD ComplexType (simpleContent)
XSD SimpleType
XSD List
XSD Union
XSD Enumeration
XSD Attribute
XSD AttributeGroup
XSD Notation
XSD Import
Beziehung
XSD Include
XSD Redefine
XSD Restriction
XSD Extension
XSD Substitution
Anmerkung
Altova UModel 2017
© 2016 Altova GmbH
Kapitel 14
Menüreferenz
410
Menüreferenz
14
Menüreferenz
Im folgenden Abschnitt sind alle Menüs und Menüoptionen in UModel mit einer kurzen
Beschreibung dazu aufgelistet.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Datei
411
14.1 Datei
Neu
Löscht das Diagrammregister, falls ein früheres Projekt vorhanden ist, und erstellt ein neues
UModel-Projekt.
Öffnen
Öffnet ein zuvor definiertes Modellierungsprojekt. Wählen Sie im Dialogfeld "Öffnen" eine zuvor
gespeicherte Projektdatei (*.ump) aus.
Nachstehend sehen Sie das Standarddialogfeld zum Öffnen von Dateien. Beachten Sie bitte die
Schaltfläche "Zu URL wechseln" am unteren Rand des Dialogfelds.
Wenn Sie auf die Schaltfläche "Zu URL wechseln" klicken, ändert sich das Aussehen des
Dialogfelds und Sie können nun eine UModel-Projektdatei über eine URL öffnen.
1. Geben Sie ins Feld Server-URL die gewünschte URL ein.
2. Geben Sie in die Felder Benutzer und Passwort die entsprechenden Daten ein, falls der
Server passwortgeschützt ist.
3. Klicken Sie auf Durchsuchen um die Verzeichnisstruktur auf dem Server zu sehen und
durch diese zu navigieren.
4. Klicken Sie auf die Datei, die in UModel geladen werden soll. Wenn es sich beim Server
um einen Microsoft® SharePoint® Server handelt, aktivieren Sie das Kontrollkästchen
Microsoft® SharePoint® Server. Nähere Informationen zum Arbeiten mit Dateien dieses
Servertyps finden Sie unter den Anmerkungen weiter unten zu Microsoft® SharePoint®
Server.
© 2016 Altova GmbH
Altova UModel 2017
412
Menüreferenz
Datei
Die Datei-URL erscheint nun im oberen Bereich des Dialogfelds im Feld "Datei-URL".
Die Schaltfläche Öffnen wird erst jetzt aktiv.
5. Klicken Sie auf die Schaltfläche Öffnen, um die Datei zu laden. Die Datei wird nun im
Hauptfenster angezeigt.
Bitte beachten Sie: Die Durchsuchen-Funktion steht nur auf Servern zur Verfügung, die
WebDAV und Microsoft SharePoint Server unterstützen. Die unterstützten Protokolle
sind FTP, HTTP und HTTPS.
Damit Sie mehr Kontrolle über den Ladevorgang haben, können Sie auswählen, ob die
Datei über den lokalen Cache-Speicher oder über einen Proxy-Server (wodurch der
Ladevorgang beträchtlich schneller geht, wenn die Datei bereits einmal geladen war)
geladen werden soll. Alternativ dazu müssen Sie die Datei eventuell neu laden, wenn Sie
z.B. mit einem EPS oder einem Datenbanksystem arbeiten; wählen Sie in diesem Fall
die Option Neu laden.
Anmerkungen zu Microsoft® SharePoint® Server
Beachten Sie bei Dateien auf Microsoft® SharePoint® Servern die folgenden Punkte:
In der Verzeichnisstruktur, die im Fenster der verfügbaren Dateien angezeigt wird
(Abbildung unten), sind die Dateisymbole mit Symbolen versehen, die den Status der
Datei (Eingecheckt/Ausgecheckt) kennzeichnen.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Datei
413
Wenn Sie mit der rechten Maustaste auf eine Datei klicken, erscheint ein Kontextmenü
mit Befehlen, die für diese Datei zur Verfügung stehen (Abbildung oben).
Im Folgenden sehen Sie die verschiedenen Dateisymbole:
Eingecheckt. Die Datei kann ausgecheckt werden.
Die Datei wurde von einem anderen Benutzer ausgecheckt und
kann nicht ausgecheckt werden.
Lokal ausgecheckt. Die Datei kann bearbeitet und eingecheckt
werden.
Nachdem Sie eine Datei ausgecheckt haben, können Sie sie in Ihrer Altova-Applikation
bearbeiten und mit Datei | Speichern (Strg+S) speichern.
Sie können die bearbeitete Datei über das Kontextmenü im Dialogfeld "URL öffnen" (siehe
Abbildung oben) einchecken.
Wenn eine Datei von einem anderen Benutzer ausgecheckt wurde, kann sie nicht
auscheckt werden.
Wenn eine Datei lokal von Ihnen ausgecheckt wurde, können Sie dies mit dem
Kontextmenübefehl "Auschecken rückgängig" rückgängig machen. In diesem Fall wird
die Datei dem Server unverändert zurückgegeben.
Wenn Sie eine Datei in einer Altova-Applikation auschecken, können Sie sie in einer
anderen Altova-Applikation nicht auschecken. Die Datei gilt bereits als für Sie
ausgecheckt. Daher stehen in diesem Fall in jeder Altova-Applikation, die Microsoft®
SharePoint® Server unterstützt, nur die Befehle Einchecken und Auschecken
rückgängig zur Verfügung.
© 2016 Altova GmbH
Altova UModel 2017
414
Menüreferenz
Datei
Neu laden
Dient zum Neuladen des aktuellen Projekts und zum Speichern oder Verwerfen der Änderungen,
die seit dem letzten Öffnen der Projektdatei vorgenommen wurden.
Speichern
Speichert das aktuell aktive Modellierungsprojekt unter dem aktiven Dateinamen.
Speichern unter
Speichert das aktuell aktive Modellierungsprojekt unter einem anderen Namen bzw. dient zum
Speichern des Projekts unter einem Namen, wenn Sie das Projekt zum ersten Mal speichern.
Kopie speichern unter
Damit können Sie eine Kopie des aktuell aktiven UModel-Projekts unter einem anderen
Dateinamen speichern.
Diagramm als Bild speichern
Öffnet das Dialogfeld "Speichern unter..." und speichert das aktuell aktive Diagramm je nach Wahl
als .png- oder .emf (Enhanced Metafile)-Datei. Es können nun auch sehr große PNG-Dateien im
Gigabyte-Bereich gespeichert werden.
Alle Diagramme als Bilder speichern
Speichert alle Diagramme des derzeit aktiven Projekts als .png- oder .emf (enhanced metafile)Datei.
Aus XMI-Datei importieren
Importiert eine zuvor exportierte XMI-Datei. Wenn die Datei mit UModel erzeugt wurde, werden alle
Erweiterungen usw. beibehalten.
In XMI-Datei exportieren
Exportiert das Modell als XMI-Datei. Sie können die UML-Version sowie die zu exportierenden IDs
auswählen. Nähere Informationen siehe XMI - XML Metadata Interchange.
Als Mail senden
Öffnet Ihre Standard-Mailapplikation und fügt das aktuelle UModel Projekt als Anhang ein.
Drucken
Öffnet das Dialogfeld "Drucken", über das Sie Ihr Modellierungsprojekt ausdrucken können.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Datei
415
Bei Auswahl der Option "Aktuelle" wird der aktuell definierte Zoomfaktor des
Modellierungsprojekts beibehalten und die Gruppe "Umbruch von Bildern" wird aktiviert.
Bei Auswahl der Option "Verhindern" wird verhindert, dass Modellelemente über Seiten hinweg
umbrochen werden. Sie werden auf einer Seite angezeigt.
Bei Auswahl von "Optimale" wird das Modellierungsprojekt an die Seitengröße angepasst. Sie
können den Zoom-Faktor auch durch Eingabe eines numerischen Werts definieren.
Alle Diagramme drucken
Öffnet das Dialogfeld "Drucken" und druckt alle in der aktuellen Projektdatei enthaltenen UMLDiagramme.
Druckvorschau
Öffnet dasselbe Druckdialogfeld mit denselben Einstellungen wie oben beschrieben.
Druckereinrichtung
Öffnet das Dialogfeld "Druckereinrichtung", in dem Sie einstellen können, welchen Drucker und
welche Papiereinstellungen Sie verwenden möchten.
© 2016 Altova GmbH
Altova UModel 2017
416
Menüreferenz
Bearbeiten
14.2 Bearbeiten
Rückgängig
UModel gestattet eine unbegrenzte Anzahl an Rückgängig-Schritten, sodass Sie Ihren
Modellierungsvorgang Schritt für Schritt zurückverfolgen können.
Wiederherstellen
Mit Hilfe des Befehls "Wiederherstellen" können Sie zuvor rückgängig gemachte Befehle
wiederholen. Sie können sich innerhalb des Verlaufs der rückgängig gemachten Schritte vorwärts
und rückwärts bewegen.
Ausschneiden/Kopieren/Löschen
Die Windows-Standardbearbeitungsbefehle gestatten Ihnen, Modellelemente auszuschneiden, zu
kopieren, usw. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und Einfügen
in UModel Diagramme.
Einfügen
Entweder über die Tastenkürzel Strg+V, den Befehl "Einfügen" aus dem Kontextmenü oder dem
gleichnamigen Befehl aus dem Menü "Bearbeiten". Fügt immer ein neues Modellelement zum
Diagramm und zur Modellstruktur hinzu. Nähere Informationen siehe "Ausschneiden, Kopieren
und Einfügen in UModel Diagramme".
Nur in Diagramm einfügen
Befehl, der über das Kontextmenü aufgerufen wird, d.h. durch Rechtsklick auf den
Diagrammhintergrund. Fügt nur einen Link/eine Ansicht eines bestehenden Elements zum
aktuellen Diagramm nicht aber zur Modell-Struktur hinzu. Nähere Informationen siehe
"Ausschneiden, Kopieren und Einfügen in UModel Diagramme".
Nur aus Diagramm löschen
Löscht die ausgewählten Modellelemente aus dem aktuell aktiven Diagramm. Die gelöschten
Elemente werden nicht aus dem Modellierungsprojekt gelöscht und stehen auf dem Register
"Modell-Struktur" zur Verfügung.
Beachten Sie, dass diese Option nicht zum Löschen von Eigenschaften oder Operationen aus
einer Klasse verfügbar ist. Eigenschaften oder Operationen können ausgewählt und direkt aus der
Klasse gelöscht werden.
Alles markieren
Markiert alle Modellelemente des aktuell aktiven Diagramms. Entspricht der Tastenkombination
Strg+A .
Suchen
Es stehen verschiedene Optionen zum Suchen von Modellelementen zur Verfügung:
Über das Textfeld in der Titelleiste
über die Menüoption Bearbeiten | Suchen
Drücken Sie die Tastenkombination Strg+F um das Dialogfeld "Suchen" zu öffnen.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Bearbeiten
417
Dient zum Suchen von bestimmtem Text:
in einem der drei Modell-Strukturbereiche: Modell-Struktur, Diagramm-Struktur und
Favoriten.
auf dem Register "Dokumentation" im Fenster "Übersicht".
in jedem aktuell aktiven Diagramm.
im Fenster "Meldungen".
Weitersuchen
F3
Sucht die nächste Instanz desselben Suchstrings auf dem derzeit aktiven Register oder im
derzeit aktiven Diagramm.
Vorheriges suchen Umschalt+F3
Sucht die vorherige Instanz desselben Suchstrings auf dem derzeit aktiven Register oder im
derzeit aktiven Diagramm.
Ersetzen
Dient zum Suchen und Ersetzen eines beliebigen Modellierungselements im Projekt. Wenn das
Element gefunden wird, wird es sowohl im Diagramm als auch in der Modell-Struktur markiert.
Suchen und Ersetzen funktioniert in:
allen Diagrammen
jedem der drei Modell-Struktur-Fenster: auf den Registern Modell-Struktur, DiagrammStruktur und Favoriten.
dem Register "Dokumentation" des Fensters "Übersicht".
© 2016 Altova GmbH
Altova UModel 2017
418
Menüreferenz
Bearbeiten
Als Bitmap kopieren
Kopiert das derzeit aktive Diagramm in die Zwischenablage, von wo aus Sie es in die Applikation
Ihrer Wahl einfügen können.
Bitte beachten Sie:
Diagramme werden in die System-Zwischenablage kopiert. Sie müssen sie in eine andere
Applikation einfügen, um sie zu sehen oder darauf zugreifen zu können.
Auswahl als Bitmap kopieren
Kopiert die aktuell ausgewählten Diagrammelemente in die Zwischenablage, von wo aus Sie
sie in die Applikation Ihrer Wahl einfügen können.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Projekt
419
14.3 Projekt
Projektsyntax überprüfen...
Überprüft die UModel-Projektsyntax. Die Projektdatei wird auf mehreren Ebenen überprüft. Siehe
Tabelle unten:
Ebene
Überprüft, ...
Meldung...
Projektebene
ob mindestens eine Java Namespace Root existiert Fehler
Komponenten ob die Projektdatei / das Verzeichnis definiert ist
Fehler
ob eine Realisierung vorhanden ist
Fehler
Bei deaktiviertem Kontrollkästchen "Für Code
Engineering verwenden" wird keine Überprüfung
durchgeführt und die Syntaxüberprüfung ist
deaktiviert
Keine
Klasse
ob der Name der Code-Datei definiert ist.
Wenn die Klasse geschachtelt ist, wird keine
Überprüfung durchgeführt.
Fehler, wenn die
lokale Option
"Fehlende
Codedateinamen
generieren" nicht
aktiviert wurde.
Warnung, wenn die
Option aktiviert ist.
ob die Klasse in einem Codesprachen-Namespace
enthalten ist
Fehler
ob der Typ für den Operationsparameter definiert ist
Fehler
ob der Typ für die Eigenschaften definiert ist
Fehler
ob der Rückgabetyp für die Operation definiert ist
Fehler
überprüft auf doppelte Operationen (Namen +
Parametertypen)
Fehler
Wenn Klassen in der Realisierung vorkommen, nur
wenn die Klasse nicht geschachtelt ist.
Warnung
Schnittstelle
ob der Codedateiname definiert ist.
ob die Schnittstelle in einem CodesprachenNamespace enthalten ist
ob der Typ für die Eigenschaften definiert ist
ob der Typ für den Operationsparameter definiert ist
ob der Rückgabetyp für die Operation definiert ist
Fehler, wenn die
lokale Option
"Fehlende
Codedateinamen
generieren" nicht
aktiviert ist.
Warnung, wenn die
Option aktiviert ist.
Fehler
© 2016 Altova GmbH
Fehler
Fehler
Fehler
Altova UModel 2017
420
Menüreferenz
Projekt
überprüft auf doppelte Operationen (Namen +
Parametertypen)
ob Schnittstellen in einer Komponentenrealisierung
vorkommen
Fehler
Enumeration
Gehört zum Java Namespace Root:
Gibt eine Warnung aus, dass kein Code generiert
wird.
Warnung
Gehört nicht zur Java Namespace Root:
Keine
Es wird keine Überprüfung durchgeführt und die
Syntaxüberprüfung ist für die Enumeration
deaktiviert. Es wird an dem enthaltenen Paket keine
Überprüfung durchgeführt
Warnung
Syntaxüberprüfung für alle an der Codegenerierung beteiligten UML-Elemente
Klasse
Überprüft, ob der Name ein gültiger Java-Name ist
(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Klasseneigenschaft
Fehler
Klassenoperation
Überprüft, ob Rückgabeparameter vorhanden sind
Fehler
Klassenoperationsparameter
Fehler
Überprüft ob der Typ einen gültigen Java-Typnamen hat
Schnittstelle
Fehler
Schnittstellenoperation
Fehler
Schnittstellenoperationsparameter
Fehler
Schnittstelleneigenschaften
Fehler
Paket mit
StereotypNamespace
Fehler
Paket ohne
StereotypNamespace
Kein zu überprüfendes Element
Keine
Klasse
Mehrfachvererbung
Fehler
Bitte beachten Sie:
Einschränkungen an Modellelementen werden nicht überprüft, da sie nicht Teil der JavaCodegenerierung sind. Nähere Informationen dazu siehe "Einschränken von
Modellelementen".
Versionskontrolle
Nähere Informationen und Anleitungen zu Versionskontrollservern und Clients finden Sie unter
Versionskontrolle.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Projekt
421
Quellverzeichnis importieren...
Öffnet das unten gezeigte Dialogfeld "Quellverzeichnis importieren". Ein Beispiel dazu finden Sie
unter "Round-Trip Engineering (Code - Modell - Code)".
Quellprojekt importieren...
Öffnet den unten gezeigten Assistenten "Quellprojekt importieren". Durch Klicken auf die
Durchsuchen-Schaltfläche
können Sie die Projektdatei und den jeweiligen Projekttyp
auswählen. Ein Beispiel dazu finden Sie unter "Importieren von Quellcode in Projekte".
Java-Projekte:
Derzeit werden JBuilder .jpx, Eclipse .project Projektdateien sowie NetBeans
(project.xml) unterstützt.
C#-Projekte:
MS Visual studio.NET-Projekte, csproj, csdprj..., sowie
Borland .bdsproj-Projektdateien
VB.NET-Projekte:
MS Visual Studio-Projekte, vbproj, vbdproj
Binärtypen importieren
Öffnet das Dialogfeld "Binärtypen importieren", über das Sie Java-, C#- und VB-Binärdateien
importieren können. Nähere Informationen dafür finden Sie unter "Importieren von Java-, C#- und
VB-Binärdateien.
XML-Schemaverzeichnis importieren
Öffnet das Dialogfeld "XML-Schemaverzeichnis importieren", über das Sie alle XML-Schemas in
diesem Verzeichnis und optional dazu alle XML-Schemas in den Unterverzeichnissen dieses
Verzeichnisses importieren können.
XML-Schema-Datei importieren
Öffnet das Dialogfeld "XML-Schema-Datei importieren" zum Importieren von Schema-Dateien.
Nähere Informationen finden Sie unter "XML-Schema-Diagramme".
Sequenzdiagramm generieren...
Öffnet das Dialogfeld "Operationen auswählen", in dem Sie (mehrere) Operationen auswählen
können, die die Basis für das generierte Sequenzdiagramm bilden sollen.
© 2016 Altova GmbH
Altova UModel 2017
422
Menüreferenz
Projekt
Nachdem Sie die Operationen ausgewählt und auf OK geklickt haben, wird das Dialogfeld
"Sequenzdiagrammgenerierung" geöffnet, in dem Sie weitere Einstellungen zur
Diagrammgenerierung vornehmen können.
Merge Programmcode aus UModel-Projekt
Öffnet das Dialogfeld "Synchronisierungseinstellungen", wobei das Register "Code von Modell"
aktiv ist. Wenn Sie auf die Schaltfläche "Projekteinstellungen" klicken, können Sie die
Einstellungen für die jeweilige Programmiersprache auswählen.
Mergen oder Überschreiben von Code
Angenommen, es wurde bereits Code anhand von einem Modell erstellt und es wurden seither
Änderungen an Modell und Code vorgenommen. z.B:
Modellelemente wurden in UModel hinzugefügt z.B. eine neue Klasse X
Eine neue Klasse wurde zum externen Code hinzugefügt z.B. Klasse Y
Mergen (eines Modells in Code) bedeutet, dass:
die neu hinzugefügte Klasse Y im externen Code beibehalten wird.
die neu hinzugefügte Klasse X aus UModel zum Code hinzugefügt wird.
Überschreiben (von Code anhand eines Modells) bedeutet, dass:
die neu hinzugefügte Klasse Y im externen Code gelöscht wird
die neu hinzugefügte Klasse X aus UModel zum Code hinzugefügt wird.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Projekt
423
Merge UModel-Projekt aus Programmcode
Öffnet das Dialogfeld "Synchronisierungseinstellungen", wobei das Register "Modell von Code"
aktiv ist. Wenn Sie auf die Schaltfläche "Projekteinstellungen" klicken, können Sie die
Einstellungen für die jeweilige Programmiersprache auswählen.
Mergen oder Überschreiben von Code
Angenommen, es wurde bereits Code anhand von einem Modell erstellt und es wurden seither
Änderungen an Modell und Code vorgenommen. z.B:
Modellelemente wurden in UModel hinzugefügt z.B. eine neue Klasse X
Eine neue Klasse wurde zum externen Code hinzugefügt z.B. Klasse Y
Mergen (von Code in das Modell) bedeutet, dass:
die neu hinzugefügte Klasse X in UModel beibehalten wird
die neu hinzugefügte Klasse Y aus externem Code zum Modell hinzugefügt wird
Überschreiben (von Code anhand eines Modells) bedeutet, dass:
die neu hinzugefügte Klasse X im externen Code gelöscht wird
die neu hinzugefügte Klasse Y aus externem Code zum Modell hinzugefügt wird.
© 2016 Altova GmbH
Altova UModel 2017
424
Menüreferenz
Projekt
Projekteinstellungen
Gestattet Ihnen das Definieren von Einstellungen für bestimmte Programmiersprachen für Ihr
Projekt.
Synchronisierungseinstellungen...
Öffnet das Dialogfeld "Synchronisierungseinstellungen", siehe Screenshot oben.
Projekt zusammenführen...
Führt zwei UModel-Projektdateien in einem Modell zusammen. Die erste Datei, die Sie öffnen, ist
die Datei, in die die zweite Datei überführt wird. Nähere Informationen dazu finden Sie unter
Zusammenführen von UModel-Projekten.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Projekt
425
Unterprojekt inkludieren
Siehe Inkludieren anderer UMdoel-Projekte.
Unterprojekt als Projekt öffnen
Öffnet das ausgewählte Unterprojekt als neues Projekt.
Meldungen löschen
Löscht die Meldungen, Warnungen und Fehler, die im Fenster "Meldungen" zur
Syntaxüberprüfung und Codezusammenführung angezeigt werden.
Bitte beachten Sie:
Fehlermeldungen weisen im Allgemeinen auf Probleme hin, die vor der Codegenerierung bzw. vor
der Aktualisierung des Modellcodes während der Codegenerierung behoben werden müssen.
Warnmeldungen weisen im Allgemeinen auf Probleme hin, die auch später behoben werden
können. Fehlermeldungen und Warnmeldungen werden von der Syntaxüberprüfung, dem Compiler
für die spezifische Sprache, dem UModel Parser, der die neu generierte Quelldatei liest, sowie
beim Import von XMI-Dateien, generiert.
Dokumentation generieren
Gestattet die Generierung von Dokumentation in den Formaten HTML, Microsoft Word und RTF
für das derzeit offene Projekt. Nähere Informationen dazu finden Sie unter Generieren von UMLDokumentation.
In keinem Diagramm verwendete Elemente auflisten
Erstellt eine Liste aller Elemente, die in keinem Diagramm des Projekts verwendet werden.
Freigegebene Pakete auflisten
Listet alle freigegebenen Pakete des aktuellen Projekts auf.
Inkludierte Pakete auflisten
Listet alle im aktuellen Projekt inkludierten Pakete auf. Die Projekte Java Profile (Java Profile.ump)
und Java Lang (Java Lang.ump) werden automatisch in dem mit UModel mitgelieferten Beispiel
"Bankview" zur Verfügung gestellt.
© 2016 Altova GmbH
Altova UModel 2017
426
Menüreferenz
Layout
14.4 Layout
Die Befehle des Menüs "Layout" gestatten Ihnen, die Elemente Ihrer Modelldiagramme
anzuordnen und aneinander auszurichten.
Bei Verwendung der Marquee-Technik (Aufziehen eines Rechtecks über dem Diagramm) zur
Markierung mehrerer Elemente wird das Element mit der strichlierten Umrandung, d.h. das zuletzt
markierte Element, zum "aktiven" Element. Bei allen Befehle zum Ausrichten wird dieses
Element als Ursprungselement verwendet, anhand dessen die folgenden Befehle ausgeführt
werden.
Ausrichten:
Dieser Befehl dient je nach Auswahl des jeweiligen Befehls zum Ausrichten von Modellelementen
entlang ihrer Ränder oder Mittelpunkte.
Gleichmäßig anordnen:
Mit dieser Gruppe von Befehlen können Sie ausgewählte Elemente sowohl in horizontaler als
auch vertikaler Richtung gleichmäßig anordnen.
Größe angleichen:
Mit Hilfe dieser Befehle können Sie die Breite und Höhe der ausgewählten Elemente anhand des
aktiven Elements anpassen.
Anordnen:
Mit Hilfe dieser Gruppe von Befehlen können Sie die ausgewählten Elemente vertikal oder
horizontal in einer Linie anordnen.
Linienart:
Mit Hilfe dieser Gruppe von Befehlen können Sie die Art der Linie auswählen, mit der die
verschiedenen Modellelemente verbunden werden sollen. Die Linien können jede Art von
Abhängigkeit oder Assoziation darstellen, die in den verschiedenen Diagrammen verwendet
werden.
Größe automatisch anpassen:
Mit diesem Befehl werden die ausgewählten Elemente an die jeweils optimale Größe angepasst.
Automatisches Layout:
Dieser Befehl dient zum Auswählen der Art, wie Modellelemente auf dem UML-Diagrammregister
dargestellt werden sollen.
Mit "Zentriert" werden die Modellelemente zentriert ausgerichtet.
Bei Auswahl von "Hierarchisch" werden die Elemente nach ihrer Beziehung, übergeordneten
Klasse, abgeleiteten Klasse usw. dargestellt.
Mit "Block" werden die Elemente nach Elementgröße gruppiert in Rechteckform dargestellt.
Textlabels neu positionieren:
Positioniert die Namen der (ausgewählten) Modellelemente zurück an ihre Standardposition.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Ansicht
427
14.5 Ansicht
Mit Hilfe der Befehle in diesem Menü können Sie:
zu Registern der verschiedenen Fenster wechseln bzw. diese aktivieren
die Sortierkriterien für die Modellelemente der Register "Modell-Struktur" und
"Favoriten" definieren
die Gruppierungskriterien der Diagramme auf dem Register "Diagramm-Struktur"
definieren
bestimmte UML-Elemente auf den Registern "Favoriten" und "Modell-Struktur" ein- oder
ausblenden
den Zoomfaktor des aktuellen Diagramms definieren
© 2016 Altova GmbH
Altova UModel 2017
428
Menüreferenz
Extras
14.6 Extras
Im Menü "Extras" können Sie:
Ihre Version anpassen: Ihre eigenen Symbolleisten, Tastaturkürzel, Menüs und Makros
definieren
die globalen Programmeinstellungen/optionen definieren
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
429
14.6.1 Benutzerdefinierte Tools
Wenn Sie den Mauszeiger über den Befehl Benutzerdefinierte Tools platzieren, wird ein
Untermenü mit benutzerdefinierten Befehlen angezeigt, die externe Applikationen verwenden. Sie
können diese Befehle im Dialogfeld "Anpassen" auf dem Register "Extras" erstellen. Wenn Sie
auf einen dieser benutzerdefinierten Befehle klicken, wird die mit diesem Befehl verknüpfte Aktion
ausgeführt.
Der Befehl Benutzerdefinierte Tools | Anpassen öffnet das Register "Extras" im Dialogfeld
"Anpassen" (Hier können Sie die benutzerdefinierten Befehle, die im Menü des Befehls
Benutzerdefinierte Tools angezeigt werden, erstellen).
© 2016 Altova GmbH
Altova UModel 2017
430
Menüreferenz
Extras
14.6.2 Anpassen...
Der Befehl "Anpassen" dient zum Anpassen von UModel an Ihre persönlichen Bedürfnisse.
Befehle
Symbolleisten
Extras
Tastatur
Menü
Optionen
Befehle
Auf dem Register "Befehle" können Sie Ihre Menüs oder Symbolleisten anpassen.
So fügen Sie einen Befehl zu einer Symbolleiste oder einem Menü hinzu:
1. Öffnen Sie dieses Dialogfeld durch Klicken auf Extras | Anpassen.
2. Wählen Sie im Listenfeld "Kategorien" die Befehlskategorie aus. Die verfügbaren Befehle
werden im Listenfeld "Befehle" angezeigt.
3. Klicken Sie auf einen Befehl in der Liste der Befehle und ziehen Sie ihn in ein
vorhandenes Menü bzw. eine vorhandene Symbolleiste.
4. Wenn Sie den Cursor über eine Position halten, an die der Befehl gezogen werden kann,
wird ein I-Zeichen angezeigt.
5. Lassen Sie die Maustaste an der Position los, an der der Befehl eingefügt werden soll.
An der Spitze des Mauszeigers erscheint beim Ziehen des Befehls eine kleine
Schaltfläche. Das Häkchen unterhalb des Mauszeigers bedeutet, dass der Befehl nicht
an der aktuellen Cursorposition abgelegt werden kann.
An den Stellen, an die der Befehl gezogen werden kann (also über der Symbolleiste oder
einem Menü) verschwindet das Häkchen.
Wenn Sie den Cursor beim Ziehen über ein Menü ziehen, wird dieses geöffnet, sodass
Sie den Befehl an einer beliebigen Stelle im Menü ablegen können.
Befehle können in Menüs oder Symbolleisten platziert werden. Wenn Sie Ihre eigene
Symbolleiste erstellt haben, können Sie darin Ihre eigenen Befehle/Symbole einordnen.
Bitte beachten Sie:
Auf dieselbe Weise können Sie auch die Befehle in den Kontextmenüs (wird durch
Rechtsklick aufgerufen) bearbeiten. Klicken Sie auf das Register "Menü" und wählen Sie
anschließend aus der Liste der Kontextmenüs das jeweilige Kontextmenü aus.
So löschen Sie einen Befehl oder ein Menü:
1. Öffnen Sie dieses Dialogfeld durch Auswahl von Extras | Anpassen.
2. Klicken Sie auf den Menüeintrag bzw. das zu löschende Symbol und ziehen Sie es mit
der Maus.
3. Lassen Sie die Maustaste los, sobald das Häkchensymbol unterhalb des Mauszeigers
erscheint.
Der Befehl bzw. der Menüeintrag wird aus dem Menü bzw. der Symbolleiste gelöscht.
Symbolleisten
Auf dem Register "Symbolleisten" können Sie bestimmte Symbolleisten aktivieren oder
deaktivieren sowie Ihre eigenen Symbolleisten erstellen.
Symbolleisten enthalten Befehle für die am häufigsten verwendeten Menübefehle. Zu jedem
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
431
Symbol erhalten Sie eine kurze Erklärung in Form eines Tooltipps, wenn Sie den Mauszeiger
direkt über das Element platzieren. In der Statusleiste wird eine detailliertere Beschreibung des
Befehls angezeigt.
Sie können die Symbolleisten von ihrer Standardposition an eine beliebige Stelle auf dem
Bildschirm ziehen, wo sie als abgedocktes Fenster angezeigt werden. Alternativ dazu können Sie
die Symbolleisten auch am linken oder rechten Rand des Hauptfensters andocken.
So aktivieren oder deaktivieren Sie eine Symbolleiste:
1. Klicken Sie auf das Kontrollkästchen, um die jeweilige Symbolleiste zu aktivieren (bzw.
zu deaktivieren).
So erstellen Sie eine neue Symbolleiste:
1. Klicken Sie auf die Schaltfläche Neu... und geben Sie der Symbolleiste im Dialogfeld
"Symbolleistenname" einen Namen.
2. Fügen Sie über das Register Befehle des Dialogfelds "Anpassen" Befehle zur
Symbolleiste hinzu.
So setzen Sie die Menüleiste zurück
Klicken Sie auf den Menüleisteneintrag und
anschließend auf die Schaltfläche Zurücksetzen, um die Menübefehle auf den Zustand
zum Zeitpunkt der Installation zurückzusetzen
So setzen Sie alle Symbolleisten- und Menübefehle zurück
Klicken Sie auf die Schaltfläche Alle zurücksetzen, um alle Symbolleistenbefehle auf
den Zustand zum Zeitpunkt der Installation des Programms zurückzusetzen. Sie werden
gefragt, ob alle Symbolleisten und Menüs zurückgesetzt werden sollen.
Klicken Sie auf "Ja", um den Vorgang zu bestätigen.
Textlabels zeigen:
Bei Aktivierung dieser Option wird erklärender Text unterhalb der Symbolleistenbefehle angezeigt.
Extras
Über das Register "Extras" können Sie im Menü "Extras" Ihre eigenen Menüeinträge und damit
verknüpften Argumente zum Starten externer Tools über das UModel Menü "Extras" erstellen.
Klicken Sie (in der Leiste "Menüinhalte") auf das Ordnersymbol, um einen neuen Menüeintrag
hinzuzufügen und verknüpfen Sie ihn über das Feld "Befehl" mit einer Anwendung.
© 2016 Altova GmbH
Altova UModel 2017
432
Menüreferenz
Extras
Auf dem Register "Extras" können nun Argumente definiert werden. Argumente sind Variablen,
denen bestimmte Werte zugewiesen werden, wenn das externe Tool über den Menübefehl
gestartet wird.
Beispiel: Öffnen der Quellcodedatei der gerade ausgewählten UML-Klasse in Notepad.
1. Wählen Sie den Menübefehl Extras | Anpassen und klicken Sie auf das Register Extras.
2. Geben Sie den Namen und Pfad der externen Applikation ein, z.B. C:\...\notepad.exe.
3. Klicken Sie auf die Flyout-Schaltfläche des Felds "Argumente" und wählen Sie das
gewünschte Argument aus, z.B. Codedateiname.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
433
4. Klicken Sie zum Fertigstellen auf die Schaltfläche "Schließen".
5. Klicken Sie auf das Menü "Extras" und wählen Sie den Eintrag "Codedatei öffnen".
Die Datei BankServer.cs wird in Nodepad geöffnet und kann bearbeitet werden.
UModel-Argumente
Projektdateiname
Der Dateiname der aktiven UModel-Projektdatei, z.B. “Test.ump”.
Projektdateipfad
Der absolute Dateipfad der aktiven UModel-Projektdatei, z.B. “c:\MyDirectory\Test.ump”.
Fokussierte UML-Daten - Name
Der Name des UML-Elements, das sich gerade im Fokus befindet, z.B. “Class1”.
Fokussierte UML-Daten - UML Qualified Name
Der qualifizierte Name des UML-Elements, das sich gerade im Fokus befindet, z.B.
“Package1::Package2::Class1”.
Fokussierte UML-Daten - Codedateiname
Der Codedateiname der im Fenster "Eigenschaften" (relativ zur realisierenden Komponente)
angegebenen UML-Klasse, -Schnittstelle oder Enumeration, die sich gerade im Fokus befindet,
z.B. “Class1.cs” oder “MyNamespace\Class1.Java”.
Fokussierte UML-Daten – Codedateipfad
Der Codedateipfad der im Fenster "Eigenschaften" angegebenen UML-Klasse, Schnittstelle oder
Enumeration die sich gerade im Fokus befindet, z.B. “C:\Temp\MySource\Class1.cs”.
© 2016 Altova GmbH
Altova UModel 2017
434
Menüreferenz
Extras
Fokussierte UML-Daten – Codeprojektdateiname
Der Dateiname des Codeprojekts, zu dem die gerade fokussierte UML-Klasse, Schnittstelle oder
Enumeration gehört.
Der Codeprojektdateiname kann relativ zur UModel-Projektdatei angegeben werden und ist
derselbe, der auch in den Eigenschaften der Komponenten angezeigt wird, z.B. “C:\Temp
\MySource\MyProject.vcproj” or “MySource\MyProject.vcproj”.
Fokussierte UML-Daten - Codeprojektdateipfad
Der Dateipfad des Codeprojekts, zu dem die gerade fokussierte UML-Klasse, Schnittstelle oder
Enumeration gehört, z.B. “C:\Temp\MySource\MyProject.vcproj”.
Tastatur
Auf dem Register "Tastatur" können Sie Tastaturkürzel für jeden beliebigen Befehl definieren (oder
ändern).
So weisen Sie einem Befehl ein neues Tastaturkürzel zu:
1. Wählen Sie im Listenfeld "Kategorie" die Befehlskategorie aus.
2. Wählen Sie in der Liste "Befehle" den Befehl aus, dem Sie ein neues Tastaturkürzel
zuweisen möchten.
3. Klicken Sie in das Textfeld "Tastaturkürzel eingeben:" und drücken Sie die Tasten, mit
denen dieser Befehl aufgerufen werden soll.
Die Tastenkombination wird sofort im Textfeld angezeigt. Falls diese Tastenkombination
bereits zugewiesen wurde, so wird diese Funktion unterhalb des Textfelds angezeigt.
4. Klicken Sie auf die Schaltfläche Zuweisen, um das Tastaturkürzel permanent
zuzuweisen.
Das Tastaturkürzel erscheint nun im Listenfeld "Aktuelle Tasten".
(Um den Eintrag in diesem Textfeld zu löschen, drücken Sie eine der Steuerungstasten:
Strg, ALT oder Umschalttaste.)
So heben Sie eine Tastenzuweisung auf (oder löschen ein Tastaturkürzel):
1. Klicken Sie in der Liste "Aktuelle Tasten" auf das zu löschende Tastaturkürzel.
2. Klicken Sie auf die jetzt aktiv gewordene Schaltfläche Entfernen.
3. Klicken Sie auf die Schaltfläche "Schließen", um alle im Dialogfeld "Anpassen"
vorgenommenen Änderungen zu bestätigen.
Menü
Auf dem Register "Menü" können Sie die Hauptmenüleisten sowie die Kontextmenüs anpassen.
Sie können sowohl die Standard- als auch die UModel-Projekt-Menüleiste anpassen.
Das Standardmenü ist das Menü, das angezeigt wird, wenn keine XML-Dokumente
irgendeiner Art geöffnet sind.
Das UModel Projektmenü ist die Menüleiste, die angezeigt wird, wenn eine *.ump-Datei
geöffnet ist.
So passen Sie ein Menü an:
1. Wählen Sie die gewünschte Menüleiste aus dem Listenfeld "Menüs anzeigen für" aus.
2. Klicken Sie auf das Register Befehle und ziehen Sie die Befehle in die Menüleiste Ihrer
Wahl.
So löschen Sie Befehle aus einem Menü:
1. Rechtsklicken Sie auf den Befehl oder das Symbol für den Befehl und
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
435
2. Wählen Sie die Option Löschen aus dem Popup-Menü aus.
oder
1. Wählen Sie Extras | Anpassen, um das Dialogfeld "Anpassen" zu öffnen und
2. Ziehen Sie die Befehl aus dem Menü und lassen Sie die Maustaste los, sobald unterhalb
des Mauszeigers ein Häkchen angezeigt wird.
So setzen Sie eine der Menüleisten zurück:
1. Wählen Sie im Listenfeld entweder den Eintrag "Standardmenü" oder "UModel-Projekt"
aus und
2. Klicken Sie unterhalb des Menünamens auf die Schaltfläche Zurücksetzen.
Sie werden daraufhin gefragt, ob Sie die Menüleiste wirklich zurücksetzen möchten.
So passen Sie eines der Kontextmenüs (Rechtsklickmenüs) an:
1. Wählen Sie das Kontextmenü aus dem Listenfeld "Kontextmenü auswählen" aus.
2. Klicken Sie auf das Register Befehle und ziehen Sie die jeweiligen Befehle in das
geöffnete Kontextmenü.
So löschen Sie Befehle aus einem Kontextmenü:
1. Rechtsklicken Sie auf den Befehl oder das Symbol für den Befehl und
2. Wählen Sie im Popup-Menü die Option Löschen aus.
oder,
1. Wählen Sie Extras | Anpassen, um das Dialogfeld "Anpassen" zu öffnen und
2. Ziehen Sie den Befehl aus dem Kontextmenü heraus und lassen Sie die Maustaste los,
sobald unterhalb des Mauszeigers ein Häkchen angezeigt wird.
So setzen Sie eines der Kontextmenüs zurück:
1. Wählen Sie das Kontextmenü aus dem Listenfeld aus und
2. Klicken Sie unterhalb des Kontextmenünamens auf die Schaltfläche Zurücksetzen.
Sie werden gefragt, ob Sie das Kontextmenü wirklich zurücksetzen möchten.
So schließen Sie ein Kontextmenüfenster:
1. Klicken Sie auf das Schließen-Symbol in der rechten oberen Ecke der Titelleiste oder
2. Klicken Sie im Dialogfeld "Anpassen" auf die Schaltfläche "Schließen".
Menüschatten
Klicken Sie auf das Kontrollkästchen "Menüschatten", wenn die Menüs mit Schatten
angezeigt werden sollen.
Optionen
Auf dem Register "Optionen" können Sie allgemeine Einstellungen vornehmen.
Wenn das Kontrollkästchen Tooltip in Symbolleiste einblenden aktiv ist, wird ein Tooltipp
angezeigt, wenn der Mauszeiger über eine Symbolleisten-Schaltfläche platziert wird. In diesem
Tooltipp wird eine kurze Beschreibung der Schaltflächenfunktion sowie das dazugehörige
Tastaturkürzel, falls eines zugewiesen wurde, angezeigt.
Wenn das Kontrollkästchen Große Symbole aktiv ist, werden anstatt der Standardsymbole
größere Symbole angezeigt.
© 2016 Altova GmbH
Altova UModel 2017
436
Menüreferenz
Extras
14.6.3 Symbolleisten und Fenster wiederherstellen
Mit diesem Befehl wird UModel geschlossen und mit den Standardeinstellungen neu gestartet.
Vor dem Schließen wird ein Dialogfeld angezeigt, in dem Sie gebeten werden, den Befehl zu
bestätigen
Dieser Befehl ist hilfreich, wenn Sie Symbolleisten oder Fenster verschoben oder ausgeblendet
oder deren Größe angepasst haben und nun alle Originaleinstellungen wiederherstellen möchten.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
437
14.6.4 Optionen
Wählen Sie den Menüeintrag Extras | Optionen, um Ihre Projektoptionen zu definieren.
Auf dem Register Ansicht können Sie folgende Einstellungen festlegen:
wo das Programmlogo angezeigt werden soll.
den Inhalt der Applikationstitelleiste
die Elementarten, die aufgelistet werden sollen, wenn Sie auf dem Register "ModelStruktur" oder "Favoriten" auf die Kontextmenüoption "In keinem Diagramm verwendete
Elemente auflisten" klicken. Sie haben auch die Möglichkeit, Elemente in inkludierten
Dateien zu ignorieren.
ob ein in einem Diagramm ausgewähltes Element in der Modell-Struktur automatisch
ausgewählt/synchronisiert werden soll.
die Standardtiefe der hierarchischen Ansicht auf dem Register "Hierarchie" bei
Verwendung der Option Graph. Ansicht anzeigen .
Die Einstellungen für automatisches hierarchisches Layout, über Sie für das
Hierarchiefenster die Verschachtelungstiefe nach oben und unten festlegen können.
"Jedes Element nur einmal erweitern". Dadurch kann im selben Bild/Diagramm kann nur
eines derselben Classifier-Elemente erweitert werden.
ob Sie Elemente beim Ziehen mit der Maus in einem Diagramm an Hilfslinien ausrichten
möchten.
Auf dem Register Bearbeiten können Sie folgende Einstellungen definieren:
Ob ein neues auf dem Register "Modell-Struktur" erstelltes Diagramm im Hauptfenster
automatisch geöffnet werden soll.
© 2016 Altova GmbH
Altova UModel 2017
438
Menüreferenz
Extras
Standardsichtbarkeit beim Hinzufügen neuer Elemente - Eigenschaften oder Operationen.
die Standard-Codesprache, wenn eine neue Komponente hinzugefügt wird.
Ob eine neu hinzugefügte Einschränkung auch ihren Besitzer (Owner) einschränken soll.
Ob Sie gefragt werden möchten, bevor Elemente aus einem Projekt, vom Register
Favoriten oder aus einem der Diagramme gelöscht werden. Wenn Sie Elemente hier
löschen, kann diese Eingabeaufforderung deaktiviert werden. Sie können die
Eingabeaufforderung "vor dem Löschen fragen" hier zurücksetzen.
Die Zeit nach der Syntaxfehler-Popup-Fenster geschlossen werden sollen.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Extras
439
Auf dem Register Diagrammbearbeitung können Sie folgende Einstellungen definieren:
wie viele Objekte automatisch zu einem Diagramm hinzugefügt werden können, bevor
eine Eingabeaufforderung erscheint.
die Anzeige von Stilen, wenn diese automatisch zu einem Diagramm hinzugefügt werden.
ob automatisch Assoziationen zwischen Modellelementen erstellt werden sollen, wenn
Elemente zu einem Diagramm hinzugefügt werden.
ob die Assoziationen zu Collections aufgelöst werden sollen.
ob Vorlagen von unbekannten externen Elementen als nicht vollständig qualifiziert
aufgelöst werden sollen.
ob bestehende Collection-Vorlagen verwendet oder neue definiert werden sollen.
Collection-Vorlagen sollten als voll qualifiziert definiert werden, also a.b.c.List. Wenn die
Vorlage diesen Namespace hat, erstellt UModel automatisch eine Collection-Assoziation.
Ausnahme: Wenn die Vorlage zum Paket der unbekannten externen Elemente gehört
und die Option "Unbekannte externe Elemente: nicht qualifizierte auflösen" aktiviert ist,
so wird nur der Vorlagenname berücksichtigt (d.h. List anstelle von a.b.c.List).
Ob das Autokomplettierungsfenster bei der Bearbeitung von Attributen oder Operationen
im Klassendiagramm verfügbar sein soll.
Auf dem Register Datei können Sie folgende Einstellungen definieren:
welche Aktionen durchgeführt werden sollen, wenn Dateien geändert werden.
ob der Inhalt des Registers "Favoriten" sowie alle derzeit offenen Diagramme mit dem
aktuellen Projekt geladen und gespeichert werden soll.
ob das zuletzt geöffnete Projekt beim Starten der Applikation automatisch geöffnet
werden soll.
ob die Projektdatei mit CR/LF-Zeilen und Tabulatoreinrückungen im Pretty-Print-Format
© 2016 Altova GmbH
Altova UModel 2017
440
Menüreferenz
Extras
gespeichert werden soll.
Auf dem Register Code Engineering können Sie folgende Einstellungen vornehmen:
die Umstände, unter denen das Meldungsfenster angezeigt werden soll.
ob alle Code-Elemente, d.h. jene, die in einer Java-, C# - oder VB-Namespace Root
enthalten sind, sowie jene, die einer Java-, C#- oder VB-Komponente zugewiesen sind,
überprüft werden sollen oder ob nur Elemente, die für das Code Engineering
verwendet werden, d.h. Elemente, bei denen das Kontrollkästchen "für Code
Engineering verwenden" aktiv ist, überprüft werden sollen.
ob im zusammenzuführenden Code fehlende Codedateinamen generiert werden sollen.
Beim Aktualisieren von Programmcode:
ob eine Syntaxüberprüfung durchgeführt werden soll.
ob fehlende Komponentenrealisierungen automatisch generiert werden sollen.
ob im zusammengeführten Code fehlende Codedateinamen generiert werden sollen
ob im Codedateipfad Namespaces verwendet werden sollen
Die im Code verwendete Einrückungsmethode, d.h. Tabulatoren oder beliebig viele
Leerzeichen
welche Verzeichnisse beim Aktualisieren eines UModel-Projekts anhand von Code oder
einem Verzeichnis ignoriert werden sollen. Trennen Sie die einzelnen Verzeichnisse
durch ein Semikolon ";". Untergeordnete Verzeichnisse desselben Namens werden
ebenfalls ignoriert.
den Pfad zur XMLSpy-Datei RootCatalog.xml, welche es UModel sowie XMLSpy
erlaubt, allgemein verwendete Schemas (sowie Stylesheets und andere Dateien) aus
lokalen Benutzerordnern aufzurufen. Dadurch wird die allgemeine
Verarbeitungsgeschwindigkeit erhöht und Benutzer können auf diese Art auch offline
arbeiten.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
© 2016 Altova GmbH
Extras
441
Altova UModel 2017
442
Menüreferenz
Extras
Auf dem Register Versionskontrolle können Sie folgende Einstellungen vornehmen:
Auswahl des aktuellen Versionskontroll-Plug-in über die Auswahlliste. Über die
Schaltfläche "Erweitert" können Sie die genauen Einstellungen für das ausgewählte
Versionskontroll-Plug-in definieren. Diese Einstellungen sind unterschiedlich, je nachdem,
welches Versionskontroll-Plug-in Sie verwenden.
Die Anmelde-ID für das Versionskontrollsystem.
Spezifische Ein- und Auscheck-Einstellungen.
Die Schaltfläche "Zurücksetzen" steht zur Verfügung, wenn Sie in einem der Dialogfelder
die Option "Wenn Dialogfelder mit "..nicht mehr anzeigen" ausgeblendet waren, klicken
Sie auf "Zurücksetzen", damit sie wieder angezeigt werden" aktiviert haben. Daraufhin
wird diese "nicht mehr anzeigen"-Meldung wieder angezeigt.
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Fenster
443
14.7 Fenster
Überlappend:
Mit diesem Befehl werden alle offenen Dokumentenfenster so angeordnet, dass sie einander
überlappend angezeigt werden.
Horizontal anordnen:
Mit diesem Befehl werden alle offenen Dokumentenfenster horizontal nebeneinander angeordnet,
sodass alle gleichzeitig sichtbar sind.
Vertikal anordnen:
Mit diesem Befehl werden alle offenen Dokumentenfenster vertikal übereinander angeordnet,
sodass alle gleichzeitig sichtbar sind.
Symbole anordnen:
Damit werden Diagramme, die beliebig und in Symbolform angeordnet sind, entlang des unteren
Rands des Diagrammansichtsbereichs positioniert.
Schließen:
Schließt das derzeit aktive Diagrammregister.
Alle schließen:
Schließt alle derzeit geöffneten Diagrammregister.
Alle bis auf das aktive schließen:
Schließt alle Diagrammregister mit Ausnahme des derzeit aktiven.
Nächstes:
Wechselt zum nächsten Modelldiagrammregister in der Reihe der Register oder zum nächsten
Hyperlink-Element.
Vorheriges:
Wechselt zum vorherigen Modelldiagrammregister in der Reihe der Register oder zum vorherigen
Hyperlink-Element.
Fensterliste:
In dieser Liste werden alle derzeit offenen Fenster angezeigt, sodass Sie zwischen ihnen
wechseln können.
Sie können auch mit Hilfe der Tastaturkürzel Strg-TAB oder Strg F6 zwischen den offenen
Fenstern hin- und herwechseln.
© 2016 Altova GmbH
Altova UModel 2017
444
Menüreferenz
Hilfe
14.8 Hilfe
Inhaltsverzeichnis
Beschreibung
Mit dem Befehl Inhaltsverzeichnis wird die Bildschirmhilfe für <%APPNAME%
geöffnet, wobei das Inhaltsverzeichnis auf der linken Seite des Hilfefensters angezeigt
wird. Das Inhaltsverzeichnis bietet eine Übersicht über das gesamte Hilfedokument.
Wenn Sie auf einen Eintrag im Inhaltsverzeichnis klicken, gelangen Sie zu diesem
Thema.
Index
Beschreibung
Mit dem Befehl Index wird die Bildschirmhilfe für UModel geöffnet, wobei auf der linken
Seite des Hilfefensters der Stichwortindex angezeigt wird. Im Index werden Stichwörter
aufgelistet und Sie können durch Doppelklick auf das Stichwort zum jeweiligen Thema
navigieren. Wenn ein Stichwort mit mehr als einem Thema verknüpft ist, können Sie das
Thema aus einer Liste von Themen auswählen.
Suchen
Beschreibung
Mit dem Befehl Suchen wird die Bildschirmhilfe für UModel geöffnet, wobei auf der
linken Seite des Hilfefensters das Suchdialogfeld angezeigt wird. Um nach einem Begriff
zu suchen, geben Sie ihn in das Eingabefeld ein und drücken Sie die Eingabetaste.
Das Hilfesystem führt eine Volltextsuche am gesamten Hilfedokument durch und gibt
eine Trefferliste zurück. Doppelklicken Sie auf einen Eintrag, um das Thema
anzuzeigen.
Software-Aktivierung
Beschreibung
Nachdem Sie Ihre Altova-Software heruntergeladen haben, können Sie sie entweder mit
Hilfe eines kostenlosen Evaluierungs-Keycode oder eines käuflich erworbenen
permanenten Lizenzkeycode aktivieren.
Kostenloser Evaluierungs-Keycode. Wenn Sie die Software zum ersten Mal
starten, wird das Dialogfeld "Software-Aktivierung" angezeigt. Es enthält eine
Schaltfläche, über die Sie einen kostenlosen Evaluierungs-Keycode anfordern
können. Geben Sie in das Dialogfeld, das daraufhin angezeigt wird, Ihren
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Hilfe
445
Namen, den Namen Ihrer Firma und Ihre E-Mail-Adresse ein und klicken Sie auf
"Jetzt anfordern!". Der Evaluierungs-Keycode wird an die von Ihnen angegebene
E-Mail-Adresse gesendet und sollte in wenigen Minuten eintreffen. Geben Sie
den Schlüssel nun im Dialogfeld "Software-Aktivierung" in das Feld Key-Code
ein und klicken Sie auf OK, um Ihr Altova-Produkt zu aktivieren. Die Software
wird für einen Zeitraum von 30 Tagen aktiviert.
Permanenter Lizenz Keycode. Das Dialogfeld "Software-Aktivierung" enthält
eine Schaltfläche, über die Sie einen permanenten Lizenz-Keycode erwerben
können. Wenn Sie auf diese Schaltfläche klicken, gelangen Sie zum Altova
Online Shop, wo Sie einen permanenten Lizenz-Keycode für Ihr Produkt
erwerben können. Bei Ihrem permanenten Lizenz-Keycode handelt es sich
entweder um eine Einzelbenutzerlizenz oder um eine Mehrfachlizenz. Beide
Arten werden per E-Mail zugesandt. Eine Einzelbenutzerlizenz enthält Ihre
Lizenzdaten, Ihren Namen, die Firma, E-Mail-Adresse und Keycode. Eine
Mehrfachlizenz enthält Ihre Lizenzdaten, ihren Firmennamen und den
Keycode. Beachten Sie, dass gemäß Ihrer Lizenzvereinbarung auf den
Computern Ihres Unternehmens nur so viele Versionen der Altova-Software
installiert werden dürfen, wie lizenziert wurden (Mehrplatzlizenz).
Anmerkung: Stellen Sie bitte sicher, dass die von Ihnen in das Registrierungsdialogfeld
eingegebenen Daten genau mit denen in Ihrer Lizenz-E-Mail übereinstimmen. Geben
Sie außerdem bei Mehrplatzlizenzen den Namen des jeweiligen Benutzers in das Feld
"Name" ein.
Das Dialogfeld "Software-Aktivierung" (Abbildung unten) kann jederzeit über den Befehl
Hilfe | Software-Aktivierung aufgerufen werden.
Sie können die Software auf die folgenden Arten aktivieren:
durch Eingabe der Lizenzschlüsselinformationen (Klicken Sie auf Neuen
Keycode eingeben) oder
durch Abruf einer Lizenz über einen Altova LicenseServer auf Ihrem Netzwerk
(klicken Sie um unteren Rand des Dialogfelds "Software-Aktivierung" auf Altova
LicenseServer verwenden). Der Altova LicenseServer muss in seinem
Lizenz-Pool eine Lizenz für Ihre Altova-Produkt haben. Wenn im LicenceServerPool eine Lizenz verfügbar ist, wird dies im Dialogfeld "Software-Aktivierung"
angezeigt (Abbildung unten) und Sie können auf Speichern klicken, um die
Lizenz abzurufen.
© 2016 Altova GmbH
Altova UModel 2017
446
Menüreferenz
Hilfe
Beachten Sie, dass eine Lizenz erst sieben Tage nach Abruf dieser Lizenz
wieder an den LicenseServer zurückgegeben werden kann. Sobald die Lizenz
durch Klick auf Lizenz zurückgeben an den Server zurückgegeben wurde,
kann sie von einem anderen Client abgerufen werden.
Altova LicenseServer bietet IT-Administratoren einen Echtzeitüberblick über alle AltovaLizenzen in einem Netzwerk. Dazu werden die Einzelheiten zu jeder Lizenz sowie
Client-Zuweisungen und die Verwendung von Lizenzen durch Clients angezeigt. Der
Vorteil der Verwendung von LicenseServer liegt in seinen Funktionen zur Verwaltung
großer Altova-Lizenzpools. Altova LicenseServer steht kostenlos auf der Altova Website
zur Verfügung. Nähere Informationen zu Altova LicenseServer und der Lizenzierung
mittels Altova LicenseServer finden Sie in der Dokumentation zu Altova LicenseServer.
Bestellformular
Beschreibung
Sobald Sie eine lizenzierte Version des Software-Produkts bestellen möchten, klicken
Sie im Dialogfeld "Software-Aktivierung" (siehe oben) auf die Schaltfläche
Permanenten Key-Code erwerben... im zum sicheren Online-Shop von Altova
weitergeleitet zu werden.
Registrierung
Altova UModel 2017
© 2016 Altova GmbH
Menüreferenz
Hilfe
447
Beschreibung
Bei Aufruf dieses Befehls wird die Altova-Produktregistrierungsseite auf einem Register
Ihres Browsers geöffnet. Durch Registrierung Ihrer Altova-Software stellen Sie sicher,
dass Sie immer die neuesten Produktinformationen erhalten.
Auf Updates überprüfen
Beschreibung
Überprüft, ob am Altova Server eine neuere Version Ihres Produkts vorhanden ist und
zeigt eine entsprechende Meldung an.
Support Center
Beschreibung
Der Befehl Support Center ist ein Link zum Altova Support Center im Internet. Im
Support Center finden Sie Antworten auf häufig gestellt Fragen, Diskussionsforen, in
denen Sie Software-Probleme besprechen können und ein Formular, um unsere
Mitarbeiter vom technischen Support zu kontaktieren.
Fragen und Antworten im Web
Beschreibung
Der Befehl Fragen und Antworten im Web ist ein Link zur Altova-Fragen- und
Antworten-Datenbank im Internet. Diese Datenbank wird ständig aktualisiert, wenn die
Mitarbeiter von Altova von unseren Kunden mit neuen Fragen konfrontiert werden.
Komponenten und Gratistools downloaden
Beschreibung
Dieser Befehl ist ein Link zum Komponenten Download Center von Altova im Internet.
Von hier können Sie Software-Komponenten verschiedener anderer Anbieter
herunterladen, die Sie mit Altova Produkten verwenden können. Dabei handelt es sich
um XSLT- und XSL-FO-Prozessoren, Applikationsserverplattformen usw. Die im
Komponenten Download Center verfügbare Software ist normalerweise kostenlos.
© 2016 Altova GmbH
Altova UModel 2017
448
Menüreferenz
Hilfe
UModel im Internet
Beschreibung
Der Befehl UModel im Internet ist ein Link zur Altova Website im Internet. Hier
erfahren Sie mehr über UModel und verwandte Technologien und Produkte auf der
Altova Website.
Über UModel
Beschreibung
Mit dem Befehl Über UModel wird das Willkommensfenster und die Versionsnummer
Ihres Produkts angezeigt. Wenn Sie die 64-Bit-Verson von UModel verwenden, wird dies
durch das Suffix (x64) nach dem Applikationsnamen angezeigt. Die 32-Bit-Version hat
kein Suffix.
Altova UModel 2017
© 2016 Altova GmbH
Kapitel 15
Code Generator
450
Code Generator
15
Code Generator
UModel enthält einen integrierten Codegenerator, der automatisch Java-, C#, Visual Basic oder
XML-Schemadateien anhand von UML-Modellen generieren kann.
Anmerkung zur Verwendung von Aliassen:
Beim Reverse Engineering von Code, der Namespace- oder Klassen-Aliasse enthält, können Sie
jetzt auswählen, ob der Alias aufgelöst werden soll (Kontrollkästchen "Aliasse auflösen" im
Dialogfeld "Quellprojekt/Verzeichnis importieren").
Beim Aktualisieren von Code, d.h. wenn der Code anhand des Modells aktualisiert wird, werden
wieder die korrekten Aliasdefinitionen verwendet. Der Geltungsbereich der Aliasdefinitionen sind
die Dateien, in denen diese vorkommen.
z.B.
using Q = System.Collections.Generic.Queue<String>;
Q myQueue;
Aliasse, bei denen es potenziell zu einem Konflikt kommen kann, werden zu den "unbekannten
externen Elementen" hinzugefügt, wenn ihre Verwendung nicht klar ist.
Anmerkung: Die Einstellung zum Auflösen von Aliassen kann jederzeit im Dialogfeld
"Projekteinstellungen" geändert werden.
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
SPL (Spy Programming Language)
451
15.1 SPL (Spy Programming Language)
In diesem Abschnitt erhalten Sie eine Übersicht über Spy Programming Language (SPL), die
Template-Sprache von Code Generator.
Es wird vorausgesetzt, dass Sie bereits über Programmiererfahrung verfügen und mit Operatoren,
Funktionen, Variablen und Klassen sowie den Grundzügen von in SPl häufig verwendeter
objektorientierter Programmierung vertraut sind.
Im Ordner \UModelspl finden Sie die von UModel verwendeten Vorlagen. Anhand dieser Dateien
können Sie Ihre eigenen Vorlagen entwickeln.
Funktionsweise von Code Generator:
Die Basis von Code Generator bilden die Vorlagendateien (.spl) und das von UModel
bereitgestellte Objektmodell. Die Vorlagendateien enthalten SPL-Anweisungen zum Erstellen von
Dateien, Lesen von Informationen aus dem Objektmodell und Ausführen von Berechnungen, die in
der Zielprogrammiersprache auch Literalcodefragmente enthalten.
Die Vorlagendatei wird von Code Generator interpretiert und je nach Vorlage wird eine .java, .csQuellcodedatei oder eine andere Dateiart ausgegeben.
© 2016 Altova GmbH
Altova UModel 2017
452
Code Generator
15.1.1 Grundlegende SPL-Struktur
Eine SPL-Datei enthält Literaltext, der ausgegeben werden soll, der zwischendurch Code
Generator-Anweisungen enthält.
Code Generator-Anweisungen sind in eckige Klammern eingeschlossen '[' und ']'. Innerhalb einer
Klammer können mehrere Anweisungen stehen. Zusätzliche Anweisungen müssen durch eine
neue Zeile oder einen Doppelpunkt ':' getrennt werden.
Gültige Beispiele sind:
[$x = 42
$x = $x + 1]
or
[$x = 42: $x = $x + 1]
Hinzufügen von Text zu Dateien
Text, der nicht innerhalb von [ und ] steht, wird direkt in die Ausgabedatei geschrieben.
Um eckige Klammern als Literale auszugeben, setzen Sie davor als Excape-Zeichen einen
umgekehrten Schrägstrich: \[ und \]. Um einen umgekehrten Schrägstrich auszugeben,
verwenden Sie \\.
Kommentare
Kommentare innerhalb eines Anweisungsblocks beginnen immer mit einem ' Zeichen und enden
an der nächsten Zeile oder an einem Zeichen, zum Beenden eines Blocks ].
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
453
15.1.2 Variablen
Jede etwas komplexere SPL-Datei enthält Variablen. Einige Variablen sind vom Code Generator
vordefiniert. Sie können jederzeit neue Variablen erstellen, indem Sie diesen Werte zuweisen.
Das $-Zeichen wird zur Deklarierung oder Verwendung einer Variablen verwendet. Vor der
Variable muss immer ein $ stehen. Bei Variablennamen muss die Groß- und Kleinschreibung
beachtet werden.
Variablentypen:
Integer - wird auch als Boolescher Wert verwendet, wobei 0 false ist und alle anderen
Werte true.
String
Objekt - wird von UModel bereitgestellt
Iterator (siehe foreach-Anweisung)
Variablentypen werden durch die erste Zuweisung deklariert.
[$x = 0]
x ist nun ein Integer.
[$x = "teststring"]
x wird nun als String behandelt.
Strings:
String-Konstanten müssen wie im oben gezeigten Beispiel immer innerhalb von doppelten
Anführungszeichen stehen. \n und \t innerhalb von doppelten Anführungszeichen werden als neue
Zeile und Tabulator interpretiert, \" ist ein literales doppeltes Anführungszeichen und \\ ist ein
umgekehrter Schrägstrich. String-Konstanten können auch mehrere Zeilen einnehmen.
Bei der Verkettung von Strings wird das & Zeichen verwendet.
[$BasePath = $outputpath & "/" & $JavaPackageDir]
Objekte
Objekte stehen für die Informationen, die im UModel-Projekt enthalten sind. Objekte haben
Eigenschaften, die über den . Operator aufgerufen werden können. In SPL können keine neuen
Objekte erstellt werden (sie werden durch den Code Generator vordefiniert, aus der InputKomponente abgeleitet). Sie können Objekte jedoch Variablen zuweisen.
Beispiel:
class [=$class.Name]
In diesem Beispiel wird das Wort "class" ausgegeben, gefolgt von einem Leerzeichen und dem
Wert der Eigenschaft Name des Objekts $class.
In der folgenden Tabelle sehen Sie die Beziehung zwischen UML-Elementen und ihren SPLEntsprechungen sowie eine kurze Beschreibung dazu.
© 2016 Altova GmbH
Altova UModel 2017
454
Code Generator
Vordefinierte Variablen
UML-Element
SPLMultiplizit
Eigenschaft
ät
BehavioralFeature isAbstract
UML
UModel
Attribute /
Association
Attribute /
Association
Beschreibung
isAbstract:Boolean
BehavioralFeature raisedExcepti
on
*
raisedException:Type
BehavioralFeature ow nedParam
eter
*
ow nedParameter:Para
meter
BehavioredClassif interfaceReali
ier
zation
*
interfaceRealization:Int
erfaceRealization
Class
ow nedOperat
ion
*
ow nedOperation:Oper
ation
Class
nestedClassif
ier
*
nestedClassifier:Classi
fier
Classifier
namespace
*
namespace:Packag packages w ith code
e
language
<<namespace>> set
Classifier
rootNamespa
ce
*
project root
namespace:String
Classifier
generalization
*
Classifier
isAbstract
ClassifierTemplate constrainingC
Parameter
lassifier
generalization:Generali
zation
isAbstract:Boolean
*
constrainingClassifier
Comment
body
DataType
ow nedAttribu
te
*
ow nedAttribute:Proper
ty
DataType
ow nedOperat
ion
*
ation
Element
kind
Element
ow ner
Element
appliedStereo
type
*
Element
ow nedComm
ent
*
ow nedComment:Comm
ent
ElementImport
importedElem
ent
1
importedElement:Packa
geableElement
Enumeration
ow nedLiteral
*
ow nedLiteral:Enumera
tionLiteral
Enumeration
nestedClassif
ier
*
nestedClassifier::Cl
assifier
Enumeration
interfaceReali
zation
*
interfaceRealization:
Interface
EnumerationLiteral ow nedAttribu
te
*
ow nedAttribute:Pro
perty
EnumerationLiteral ow nedOperat
ion
*
ow nedOperation:Op
eration
Altova UModel 2017
VB only - root
namespace
body:String
kind:String
0..1
ow ner:Element
appliedStereotype:S applied stereotypes
tereotypeApplicatio
n
© 2016 Altova GmbH
Code Generator
EnumerationLiteral nestedClassif
ier
*
nestedClassifier:Cla
ssifier
Feature
isStatic
Generalization
general
1
general:Classifier
Interface
ow nedAttribu
te
*
ty
Interface
ow nedOperat
ion
*
ation
Interface
nestedClassif
ier
*
nestedClassifier:Classi
fier
1
contract:Interface
InterfaceRealizatio contract
n
isStatic:Boolean
MultiplicityElement low erValue
0..1
low erValue:ValueSpe
cification
MultiplicityElement upperValue
0..1
upperValue:ValueSpe
cification
NamedElement
name
name:String
NamedElement
visibility
visibility:VisibilityKind
NamedElement
isPublic
isPublic:Boolean
NamedElement
isProtected
isProtected:Boolean visibility <protected>
NamedElement
isPrivate
isPrivate:Boolean
visibility <private>
NamedElement
isPackage
isPackage:Boolean
visibility <package>
NamedElement
namespacePr
efix
namespacePrefix:St XSD only - namespace
ring
prefix w hen exists
NamedElement
parseableNa
me
parseableName:Stri CSharp, VB only - name
ng
w ith escaped
keyw ords (@)
Namespace
elementImport
*
Operation
ow nedReturn
Parameter
0..1
ow nedReturnParam parameter w ith direction
eter:Parameter
return set
Operation
type
0..1
type
Operation
ow nedOperat
ionParameter
*
ow nedOperationPar all parameters excluding
ameter:Parameter
parameter w ith direction
return set
Operation
implementedIn
terface
1
implementedInterfac CSharp only - the
e:Interface
implemented interface
Operation
ow nedOperat
ionImplementa
tions
*
implementedOperati VB only - the
on:OperationImplem implemented interfaces/
entation
operations
OperationImpleme implementedO
ntation
perationOw n
er
1
implementedOperati interface implemented
onOw ner:Interface by the operation
visibility <public>
elementImport:ElementI
mport
type of parameter w ith
direction return set
ntation
perationName
name:String
ntation
perationParse
ableName
parseableName:Stri name of the
ng
implemented operation
w ith esacped
keyw ords
© 2016 Altova GmbH
455
name of the
implemented operation
Altova UModel 2017
456
Code Generator
Package
namespace
*
namespace:Packag packages w ith code
e
language
<<namespace>> set
PackageableEleme ow ningPacka
nt
ge
0..1
ow ningPackage
set if ow ner is a
package
PackageableEleme ow ningName
nt
spacePackag
e
0..1
ow ningNamespace ow ning package w ith
Package:Package
code language
<<namespace>> set
Parameter
direction
direction:ParameterDir
ectionKind
Parameter
isIn
isIn:Boolean
direction <in>
Parameter
isInOut
isInOut:Boolean
direction <inout>
Parameter
isOut
isOut:Boolean
direction <out>
Parameter
isReturn
isReturn:Boolean
direction <return>
Parameter
isVarArgList
isVarArgList:Boolea true if parameter is a
n
variable argument list
Parameter
defaultValue
0..1
defaultValue:ValueSp
ecification
Property
defaultValue
0..1
defaultValue:ValueSp
ecification
RedefinableEleme isLeaf
nt
Slot
name
Slot
values
Slot
isLeaf:Boolean
name:String
name of the defining
feature
value
value:String
value of the first value
specification
StereotypeApplica name
tion
name:String
name of applied
stereotype
taggedValue:Slot
first slot of the instance
specification
StereotypeApplica taggedValue
tion
*
value:ValueSpecificati
on
*
StructuralFeature isReadOnly
isReadOnly
StructuredClassifi ow nedAttribu
er
te
*
ty
TemplateBinding
signature
1
signature:TemplateSig
nature
TemplateBinding
parameterSu
bstitution
*
parameterSubstitution:
TemplateParameterSu
bstitution
TemplateParamete paramDefault
r
TemplateParamete ow nedParam
r
eteredElemen
t
paramDefault:String template parameter
default value
1
ow nedParameteredEle
ment:ParameterableEle
ment
TemplateParamete parameterSu
rSubstitution
bstitution
parameterSubstituti Java only - code
on:String
w ildcard handling
TemplateParamete parameterDim
rSubstitution
ensionCount
parameterDimension code dimension count
Count:Integer
of the actual parameter
TemplateParamete actual
rSubstitution
Altova UModel 2017
1
Ow nedActual:Paramet
erableElement
© 2016 Altova GmbH
Code Generator
TemplateParamete formal
rSubstitution
1
formal:TemplateParam
eter
TemplateSignature template
1
template:Templateable
Element
TemplateSignature ow nedParam
eter
*
ow nedParameter:Tem
plateParameter
TemplateableElem isTemplate
ent
isTemplate:Boolean true if template
signature set
TemplateableElem ow nedTempl
ent
ateSignature
0..1
ow nedTemplateSignat
ure:TemplateSignature
TemplateableElem templateBindi
ent
ng
*
templateBinding:Templ
ateBinding
Type
typeName
*
TypedElement
type
TypedElement
postTypeModi
fier
ValueSpecificatio value
n
457
0..1
typeName:Packagea qualified code type
bleElement
names
type:Type
postTypeModifier:St postfix code modifiers
ring
value:String
string value of the value
specification
Hinzufügen eines Präfixes zu Attributen einer Klasse bei der Codegenerierung
Eventuell müssen Sie allen neuen Attributen in Ihrem Projekt die Zeichen "m_" voranstellen.
Alle neuen Kodierungselemente werden unter Verwendung der SPL-Vorlagen geschrieben:
Wenn Sie einen Blick in UModelSPL\C#[Java]\Default\Attribute.spl werfen, können Sie die
Schreibweise des Namens ändern, z.B. können Sie
write $Property.name
durch
write "m_" & $Property.name
ersetzen
Es wird unbedingt empfohlen, Ihr Modell sofort nach der Codegenerierung anhand des Codes
aktualisieren, um sicherzustellen, dass Code und Modell synchron sind.
Bitte beachten Sie:
Kopieren Sie, wie bereits erwähnt, die SPL-Vorlagen ein Verzeichnis höher hinein (d.h. oberhalb
des Standardverzeichnisses für UModelSPL\C#) bevor Sie sie ändern. Damit stellen Sie sicher,
dass sie bei Installation einer neuen Version von UModel nicht überschrieben werden. Stellen Sie
bitte sicher, dass Sie im Dialogfeld "Synchronisierungseinstellungen" auf dem Register Code von
Modell das Kontrollkästchen "Benutzerdefinierte setzt Standardvorlage außer Kraft" aktiviert
haben.
SPL-Vorlagen
SPL-Vorlagen können über die Menüoption Projekt | Projekteinstellungen (siehe Abbildung
unten) pro UModel-Projekt definiert werden. Auch relative Pfade werden unterstützt. Vorlagen, die
im angegebenen Verzeichnis nicht gefunden werden, werden im lokalen Standard-Verzeichnis
gesucht.
© 2016 Altova GmbH
Altova UModel 2017
458
Code Generator
Globale Objekte
$Options
$Indent
$IndentStep
$NamespacePrefix
ein Objekt, das globale Optionen enthält:
generateComments:bool doc-Kommentare generieren (true/false)
ein String zum Einrücken von generiertem Code und zur Anzeige der
aktuellen Verschachtelungsebene.
ein String zum Einrücken von generiertem Code und zur Darstellung
einer Verschachtelungsebene.
nur XSD – das Target Namespace Präfix, falls vorhanden
Routinen zur Behandlung von Strings
integer Compare(s)
Der Rückgabewert gibt die lexikographische Beziehung des String zu s an (unter
Berücksichtigung der Groß- und Kleinschreibung):
<0:
der String ist kleiner als s
0:
der String ist identisch mit s
>0:
der String ist größer als s
integer CompareNoCase(s)
Der Rückgabewert gibt die lexikographische Beziehung des String zu s an (ohne
Berücksichtigung der Groß- und Kleinschreibung):
<0:
der String ist kleiner als s
0:
der String ist identisch mit s
>0:
der String ist größer als s
integer Find( s )
Durchsucht den String nach der ersten Instanz eines Substring s.
Gibt den nullbasierten Index des ersten Zeichens von s oder -1 zurück, wenn s nicht gefunden
wird.
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
459
string Left( n )
Gibt die ersten n Zeichen des String zurück.
integer Length()
Gibt die Länge des String zurück.
string MakeUpper()
Gibt einen String zurück, der in Großbuchstaben konvertiert wurde.
string MakeUpper( n )
Gibt einen String zurück, dessen erste n Zeichen in Großbuchstaben konvertiert wurden.
string MakeLower()
Gibt einen String zurück, der in Kleinbuchstaben konvertiert wurde.
string MakeLower( n )
Gibt einen String zurück, dessen erste n Zeichen in Kleinbuchstaben konvertiert wurden.
string Mid( n )
Gibt einen String zurück, der mit der nullbasierten Indexposition n beginnt
string Mid( n, m )
Gibt einen String zurück, der mit der nullbasierten Indexposition n beginnt und die Länge m hat
string RemoveLeft( s )
Gibt einen String zurück, der den Substring s ausnimmt, wenn Left( s.Length() ) dem Substring s
entspricht.
string RemoveLeftNoCase( s )
Gibt einen String zurück, der den Substring s ausnimmt, wenn Left( s.Length() ) dem Substring s
entspricht (Groß- und Kleinschreibung wird ignoriert).
string RemoveRight( s )
Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substring s
entspricht.
string RemoveRightNoCase( s )
Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substring s
entspricht (Groß- und Kleinschreibung wird ignoriert).
string Repeat( s, n )
Gibt einen String zurück, der den Substring s n mal enthält.
string Right( n )
Gibt die letzten n Zeichen des String zurück.
© 2016 Altova GmbH
Altova UModel 2017
460
Code Generator
15.1.3 Operatoren
Operatoren in SPL funktionieren wie in den meisten anderen Programmiersprachen.
Liste von SPL-Operatoren absteigend nach Vorrangigkeit gereiht:
.
( )
true
false
Objekteigenschaft aufrufen
Gruppierung eines Ausdrucks
Boolesche Konstante "true"
Boolesche Konstante "false"
&
String-Verkettung
not
Zeichen für negative Zahl
Logische Negation
*
/
%
Multiplizieren
Dividieren
Modulo
+
-
Addieren
Subtrahieren
<=
<
>=
>
Kleiner oder gleich
Kleiner als
Größer oder gleich
Größer als
=
<>
Gleich
Nicht gleich
and
or
Logische Konjunktion (mit short circuit-Auswertung)
Logische Disjunktion (mit short circuit-Auswertung)
=
Zuweisung
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
461
15.1.4 Bedingungen
SPL erlaubt die Verwendung von Standard-"if"-Anweisungen. Die Syntax lautet wie folgt:
if condition
statements
else
statements
endif
or, without else:
if condition
statements
endif
Beachten Sie bitte, dass für die Bedingung keine runden Klammern verwendet werden!
Wenn in allen anderen Programmiersprachen werden Bedingungen mit logischen und
Vergleichsoperatoren konstruiert.
Bedingungen:
Wie bei jeder anderen Programmiersprache, werden Bedingungen mit logischen und
Vergleichsoperatoren erstellt:
Beispiel:
[if $namespace.ContainsPublicClasses and $namespace.Prefix <> ""]
whatever you want ['inserts whatever you want, in the resulting file]
[endif]
Switch
SPL enthält auch eine Multiple Choice-Anweisung.
Syntax:
switch $variable
case X:
statements
case Y:
case Z:
statements
default:
statements
endswitch
Die Case-Bezeichnungen müssen Konstanten oder Variablen sein.
Die switch-Anweisung in SPL fällt nicht durch die Cases (wie in C), daher wird auch keine
"break"-Anweisung benötigt.
© 2016 Altova GmbH
Altova UModel 2017
462
Code Generator
15.1.5 Collections und foreach
Collections und Iteratoren
Eine Collection enthält mehrere Objekte - wie ein gewöhnliches Array. Iteratoren lösen das
Problem des Speicherns und Inkrementierens von Array Indizes beim Aufrufen von Objekten.
Syntax:
foreach iterator in collection
statements
next
Beispiel:
[foreach $class in $classes
if not $class.IsInternal
]
class [=$class.Name];
[
endif
next]
Beispiel 2:
[foreach $i in 1 To 3
Write "// Step " & $i & "\n"
‘ Do some work
next]
Foreach iteriert durch alle Datenelemente in $classes und führt für die Anweisung den Code der
auf die Anweisung folgt, bis zur nächsten Anweisung aus.
In jeder Iteration wird $class dem nächsten Klassenobjekt zugewiesen. Sie arbeiten einfach mit
dem Klassenobjekt, anstelle classes[i]->class->Name(), zu verwenden, wie das in C++ der Fall
wäre.
Alle Collection-Iteratoren haben die folgenden zusätzlichen Eigenschaften:
Index
der aktuelle Index beginnend mit 0
IsFirst
true, wenn das aktuelle Objekt das erste der Collection ist (Index ist 0)
IsLast
true, wenn das aktuelle Objekt das letzte einer Collection ist
Beispiel:
[foreach $enum in $facet.Enumeration
if not $enum.IsFirst
], [
endif
]"[=$enum.Value]"[
next]
Routinen zur Bearbeitung von Collections:
collection SortByName( bAscending )
gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge (unter
Berücksichtigung der Groß- und Kleinschreibung) nach Namen sortiert sind .
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
463
collection SortByNameNoCase( bAscending )
gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge (ohne
Berücksichtigung der Groß- und Kleinschreibung) nach Namen sortiert sind .
Beispiel:
$SortedNestedClassifier = $Class.nestedClassifier.SortByNameNoCase( true )
collection SortByKind( bAscending )
gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge nach
kind-Namen (z.B. “Class”, “Interface”,…) sortiert sind.
collection SortByKindAndName( bAscendingKind, bAscendingName )
"kind" (z.B. “Class”, “Interface”,…) sortiert sind, wobei berücksichtigt wird, ob die "kinds" sortiert
in aufsteigender oder absteigender Reihenfolge (unter Berücksichtigung der Groß- und
Kleinschreibung) im Namen identisch sind.
collection SortByKindAndNameNoCase( bAscending )
"kind" (z.B. “Class”, “Interface”,…) sortiert sind, wobei berücksichtigt wird, ob die "kinds" sortiert
in aufsteigender oder absteigender Reihenfolge (ohne Berücksichtigung der Groß- und
Kleinschreibung) im Namen identisch sind.
© 2016 Altova GmbH
Altova UModel 2017
464
Code Generator
15.1.6 Subroutinen
Code Generator unterstützt nun Subroutinen in der Form von Prozeduren oder Funktionen.
Funktionen:
Übergabe von Werten nach Wert und nach Referenz
Lokale/globale Parameter (lokal innerhalb von Subroutinen)
Lokale Variablen
Rekursiver Aufruf (Subroutinen können sich selbst aufrufen)
Deklaration einer Subroutine
Subroutinen
Syntax-Beispiel:
Sub SimpleSub()
... lines of code
EndSub
Sub ist das Schlüsselwort, das die Prozedur notiert.
SimpleSub ist der Name, der der Subroutine zugewiesen wurde.
Runde Klammern können eine Parameterliste enthalten.
Der Code-Block einer Subroutine beginnt direkt nach der geschlossenen Klammer nach
dem Parameter.
EndSub notiert das Ende des Code-Blocks.
Bitte beachten Sie:
Eine rekursive oder kaskadierende Subroutine-Deklaration ist nicht zulässig, d.h. eine
Subroutine darf keine weiteren Subroutinen enthalten.
Parameter
Parameter können auch durch Prozeduren unter Verwendung der folgenden Syntax übergeben
werden:
Alle Parameter müssen Variablen sein
Variablen muss das $-Zeichen vorangestellt werden
Lokale Variablen werden in einer Subroutine definiert
Globale Variablen werden explizit außerhalb von Subroutinen deklariert
Mehrere Parameter werden innerhalb runder Klammern durch Kommas "," voneinander
getrennt
Parameter können Werte übergeben
Parameter - Übergabe von Werten
Parameter können auf zwei Arten übergeben werden: nach Wert oder nach Referenz, wobei die
Schlüsselwörter ByVal bzw. ByRef verwendet werden.
Syntax:
' define sub CompleteSub()
[Sub CompleteSub( $param, ByVal $paramByValue, ByRef $paramByRef )
] ...
Altova UModel 2017
© 2016 Altova GmbH
Code Generator
465
ByVal definiert, dass der Parameter nach Wert übergeben wird. Beachten Sie, dass die
meisten Objekte nur nach Referenz übergeben werden können.
ByRef definiert, dass der Parameter nach Referenz übergeben wird. Dies ist die
Standardeinstellung, wenn weder ByVal noch ByRef definiert ist.
Funktionsrückgabewerte
Für die Rückgabe eines Werts von einer Subroutine verwenden Sie ein Return-Statement. Eine
solche Funktion kann von innerhalb eines Ausdrucks aufgerufen werden.
Beispiel:
' define a function
[Sub MakeQualifiedName( ByVal $namespacePrefix, ByVal $localName )
if $namespacePrefix = ""
return $localName
else
return $namespacePrefix & ":" & $localName
endif
EndSub
]
Subroutinenaufruf
Verwenden Sie zum Aufrufen einer Subroutine call, gefolgt vom Namen der Prozedur und ggf. den
Parametern.
Call SimpleSub()
oder,
Call CompleteSub( "FirstParameter", $ParamByValue, $ParamByRef )
Funktionsaufruf
Um eine Funktion (jede Subroutine, die ein Return-Statement enthält) aufzurufen, verwenden Sie
einfach deren Namen in einem Ausdruck. Verwenden Sie zum Aufrufen von Funktionen nicht das
Call-Statement.
Beispiel:
$QName = MakeQualifiedName($namespace, "entry")
© 2016 Altova GmbH
Altova UModel 2017
466
Code Generator
Fehlercodes
15.2 Fehlercodes
Betriebssystem-Fehlercodes
201
Datei nicht gefunden: '%s'
202
Datei '%s' kann nicht erstellt werden
203
Datei '%s' konnte nicht geöffnet werden
204
Datei '%s' kann nicht in '%s' kopiert werden
Syntax-Fehlercodes
401
Keyword erwartet
402
'%s' erwartet
403
Es wurde keine Output-Datei angegeben
404
Unerwartetes Dateiende
405
Keyword nicht zulässig
Runtime-Fehlercodes
501
Unbekannte Variable '%s'
502
Umdefinition der Variablen '%s'
503
Variable '%s' ist kein Container
504
Unbekannte Eigenschaft '%s'
505
Kann %s nicht in %s konvertieren
507
Unbekannte Funktion
508
Funktion ist bereits definiert
509
Ungültiger Parameter
510
Division durch Null
511
Unbekannte Methode
512
Falsche Parameteranzahl
513
Stapelüberlauf
Altova UModel 2017
© 2016 Altova GmbH
Kapitel 16
Lizenzinformationen
468
Lizenzinformationen
16
Lizenzinformationen
Dieser Anhang enthält die folgenden Informationen:
Informationen über den Vertrieb dieses Software-Produkts
Informationen zur Software-Aktivierung und Lizenzüberwachung
Informationen im Zusammenhang mit dem intellektuellen Eigentum dieses SoftwareProdukts
die Endbenutzer-Lizenzvereinbarung zu diesem Software-Produkt
Lesen Sie die Informationen bitte sorgfältig - sie sind rechtlich bindend, da Sie sich bei der
Installation dieses Software-Produkts damit einverstanden erklärt haben.
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
Electronic Software Distribution
469
16.1 Electronic Software Distribution
Dieses Produkt ist über EDS (Electronic Software Distribution), also auf elektronischem Weg
erhältlich, eine Methode, die die folgenden einzigartigen Vorteile bietet:
Sie können die Software kostenlos testen, bevor Sie sich zu einem Kauf entscheiden.
Wenn Sie sich entschieden haben, die Software zu kaufen, können Sie Ihre Bestellung
online abgeben und das Produkt steht Ihnen sofort im vollen Lizenzumfang zur Verfügung.
Sie erhalten immer die neueste Version unserer Software
Die Software enthält ein umfassendes Online-Hilfesystem. Die neueste Version des
Benutzerhandbuchs steht auf unserer Website www.altova.com (i) im HTML-Format zum
Aufrufen online und (ii) im PDF-Format zum Download und Ausdrucken zur Verfügung.
30-Tage-Evaluierungszeitraum
Nachdem Sie dieses Software-Produkt heruntergeladen haben, können Sie es 30 Tage lang
kostenlos testen. Während dieses Zeitraums werden Sie nach etwa 20 Tagen in regelmäßigen
Abständen daran erinnert, dass die Software noch nicht lizenziert wurde. Diese
Erinnerungsmeldung wird allerdings nur einmal, nämlich bei jedem Start des Programms,
angezeigt. Wenn Sie das Programm nach Ablauf des 30-tägigen Evaluierungszeitraums
weiterverwenden möchten, müssen Sie eine Altova Software-Lizenz erwerben, die Sie in Form
eines Keycodes erhalten, der in das Dialogfeld "Software-Aktivierung" eingegeben werden muss,
um das Produkt zu aktivieren. Sie können Ihre Lizenz online in unserem Web-Shop unter Altova
Shop erwerben.
Weitergabe der Software an andere Mitarbeiter in Ihrem Unternehmen zu Testzwecken
Wenn Sie die Evaluierungsversion der Software auch anderen Personen in Ihrem Unternehmen
über das Netzwerk zur Verfügung stellen möchten oder wenn Sie sie auf einem PC installieren
möchten, der nicht mit dem Internet verbunden ist, sollten Sie nur das Installationsprogramm
weitergeben - vorausgesetzt es wurde nicht modifiziert. Jeder, der das von Ihnen zur Verfügung
gestellte Installationsprogramm aufruft, muss einen eigenen Evaluierungs-Keycode für 30 Tage
anfordern. Nach Ablauf des Testzeitraums, muss eine Lizenz erworben werden, damit das
Produkt weiter verwendet werden kann.
Nähere Informationen finden Sie in der Altova Software-Lizenzvereinbarung am Ende dieses
Handbuchs.
© 2016 Altova GmbH
Altova UModel 2017
470
Lizenzinformationen
Software-Aktivierung und Lizenzüberwachung
16.2 Software-Aktivierung und Lizenzüberwachung
Im Rahmen der Aktivierung der Software durch Altova, verwendet die Software unter Umständen
Ihr internes Netzwerk und Ihre Internetverbindung, um die Lizenzdaten während der Installation,
Registrierung, der Verwendung oder der Aktualisierung an einen von Altova betriebenen
Lizenzserver zu übertragen und die Authentizität der Lizenzdaten zu überprüfen, damit AltovaSoftware nicht ohne Lizenz oder auf unzulässige Art und Weise verwendet werden kann und um
den Kundenservice gleichzeitig zu verbessern. Bei der Aktivierung werden zwischen Ihrem
Computer und dem Altova-Lizenzserver für die Lizenzierung erforderliche Daten wie Informationen
über Betriebssystem, IP-Adresse, Datum/Uhrzeit, Software-Version und Computername sowie
andere Informationen ausgetauscht.
Ihr Altova-Produkt verfügt über ein integriertes Lizenzüberwachungsmodul, das ebenfalls dazu
beiträgt, unbeabsichtigte Verletzungen der Lizenzvereinbarung zu vermeiden. Ihr Produkt kann
entweder mit einer Einzelplatzlizenz oder einer Mehrfachlizenz erworben werden. Je nach Lizenz
stellt das Lizenzüberwachungsmodul sicher, dass nicht mehr als die lizenzierte Anzahl an
Benutzern die Applikation gleichzeitig verwendet.
Bei dieser Lizenzüberwachungsmethode wird Ihr LAN-Netzwerk verwendet, um die
Kommunikation zwischen Instanzen der Applikation, die auf verschiedenen Computern laufen, zu
überwachen.
Einzelplatzlizenz
Beim Start der Applikation wird im Rahmen der Lizenzüberprüfung ein kurzes BroadcastDatagramm abgesendet, um andere Instanzen des Produkts, die auf anderen Computern im
selben Netzwerk laufen, zu finden. Wenn keine Antwort einlangt, wird ein Port geöffnet, der
Informationen von anderen Instanzen der Applikation empfangen kann.
Mehrfachlizenz
Wenn Sie im selben LAN mehrere Instanzen der Applikation verwenden, kommunizieren diese
beim Start kurz miteinander, um Keycode-Informationen auszutauschen, damit Sie sicher sein
können, dass nicht mehr als die lizenzierte Anzahl an Lizenzen gleichzeitig in Verwendung ist.
Dieselbe Lizenzüberwachungstechnologie wird auch bei Unix und vielen anderen
Datenbankentwicklungstools verwendet. Sie gestattet Benutzern den Erwerb von Parallellizenzen
für mehrere Benutzer zu vernünftigen Preisen.
Wir sind außerdem bestrebt, nur wenige, kleine Netzwerkpakete zu versenden, um Ihr Netzwerk
nicht zu überlasten. Die von Ihrem Altova Produkt verwendeten TCP/IP Ports (2799) sind offiziell
bei IANA registriert, (nähere Informationen siehe IANA Website (http://www.iana.org/)) und unser
Lizenzüberwachungsmodul basiert auf einer bewährten und erprobten Technologie.
Wenn Sie eine Firewall verwenden, werden Sie unter Umständen feststellen, dass die Computer,
auf denen Altova-Produkte laufen, über Port 2799 miteinander kommunizieren. Sie können diesen
Netzwerkverkehr zwischen verschiedenen Gruppen in Ihrem Unternehmen natürlich blockieren,
solange Sie mit anderen Mitteln sicherstellen können, dass Ihre Lizenzvereinbarung eingehalten
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
Software-Aktivierung und Lizenzüberwachung
471
wird.
Sie werden außerdem auch feststellen, dass Ihr Altova Produkt viele nützliche Funktionen enthält,
die Ihre Internet-Verbindung verwenden, diese stehen jedoch nicht mit der
Lizenzüberwachungsfunktion in Zusammenhang.
© 2016 Altova GmbH
Altova UModel 2017
472
Lizenzinformationen
Rechte am geistigen Eigentum
16.3 Rechte am geistigen Eigentum
Die Software und alle Kopien, deren Anfertigung Ihnen von Altova gestattet ist, sind das geistige
Eigentum von Altova und dessen Lieferanten und stehen in deren Besitz. Struktur, Organisation
und Code der Software stellen wertvolle Betriebsgeheimnisse und vertrauliche Informationen von
Altova und dessen Lieferanten dar. Die Software ist durch gesetzliche Bestimmungen
urheberrechtlich geschützt. Diese gesetzlichen Bestimmungen beinhalten (ohne darauf
beschränkt zu sein) das Urheberrecht der Vereinigten Staaten, internationale Verträge und das in
den Ländern, in denen die Software genutzt wird, geltende Recht. Altova behält sich das
Eigentum an allen Patenten, Urheberrechten, Branchengeheimnissen, Warenzeichen und
sonstigen geistigen Eigentumsrechten, die hinsichtlich der Software bestehen, vorbehält. Das
Eigentumsrecht von Altova erstreckt sich auch auf alle Bilder, Fotografien, Animationen, Videos,
Audioaufzeichnungen, Musikstücke, Texte und „Applets“, die Teil der Software sind, und alle
dazugehörigen Unterlagen in gedruckter Form. Mitteilungen über geltend gemachte Verstöße
gegen geistige Eigentumsrechte sind an den Copyright Agenten von Altova zu richten (nähere
Angaben dazu finden Sie auf der Website von Altova).
Altova Software enthält Software-Komponenten Dritter, die ebenfalls urheberrechtlich geschützt
sind. Unter anderem sind diese Urheberrechte ausführlich unter http://www.altova.com/
legal_3rdparty.html aufgelistet.
Alle anderen Namen oder Warenzeichen sind das Eigentum ihrer jeweiligen Inhaber.
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
Altova Endbenutzer-Lizenzvereinbarung
473
16.4 Altova Endbenutzer-Lizenzvereinbarung
DIES IST EIN RECHTSGÜLTIGES DOKUMENT -- BITTE BEWAHREN SIE ES SORGFÄLTIG
AUF
ALTOVA® ENDBENUTZER-LIZENZVERTRAG
Lizenzgeber:
Altova GmbH
Rudolfsplatz 13a/9
A-1010 Wien
Österreich
Wichtig – Bitte sorgfältig lesen. Benutzerinformation:
Dieser Endbenutzer-Lizenzvertrag („Vertrag“) ist ein rechtsgültiger Vertrag, der zwischen
Ihnen und Altova GmbH („Altova“) abgeschlossen wurde. Bevor Sie die von Altova
bereitgestellte Software („Software“) sowie die dazugehörige Dokumentation (u.a.
Unterlagen in gedruckter Form, Online-Dateien oder Dokumentation in elektronischer
Form („Dokumentation“) verwenden, lesen Sie bitte dieses Dokument sorgfältig durch.
Indem Sie auf die untenstehenden Schaltflächen „Ich akzeptiere“ und „Weiter“ klicken,
oder indem Sie die Software installieren oder auf sonstige Weise nutzen, stimmen Sie
zu, dass Sie die Bedingungen dieses Vertrags sowie die Datenschutzbestimmungen
(„Datenschutzbestimmungen“) von Altova, inklusive jedoch nicht ausschließlich die
nachfolgend festgelegten Garantieausschlüsse, Haftungsbeschränkungen sowie
Datennutzungs- und Kündigungsregelungen als rechtsverbindlich anerkennen, auch
wenn Sie die Software nicht käuflich erwerben. Sie stimmen zu, dass diese
Vereinbarung in demselben Umfang gültig und durchsetzbar ist, wie ein von Ihnen
persönlich unterzeichneter Vertrag. Wenn Sie den Bedingungen dieses Lizenzvertrags nicht
zustimmen, sind Sie nicht zur Verwendung der Software berechtigt und müssen alle
heruntergeladenen Kopien, die sich in Ihrem Besitz oder unter Ihrer Kontrolle befinden, vernichten.
Während des Installationsvorganges können Sie eine Kopie dieses Vertrages zum Zeitpunkt Ihrer
Zustimmung ausdrucken. Auf unserer Website finden Sie eine Kopie dieses Vertrags unter http://
www.altova.com/de/eula. Eine Kopie der Datenschutzbestimmungen kann unter http://
www.altova.com/de/privacy eingesehen werden.
1. SOFTWARELIZENZ
(a)
Lizenzgewährung.
(i) Sofern Sie diesem Vertrag zugestimmt haben, gewährt Ihnen Altova eine nicht
ausschließliche und nicht übertragbare (mit Ausnahme der nachfolgenden Bestimmungen)
Lizenz, ohne das Recht zur Vergabe von Sublizenzen, zur Installation und Verwendung der
Software auf einem kompatiblen Einzelplatzrechner oder einer Workstation im selben LAN, wobei
die maximale Zahl an Computern, die im Lizenzumfang enthalten sind, nicht überschritten werden
darf. Vorbehaltlich der Beschränkungen gemäß Abschnitt 1 (c), dürfen Sie eine Kopie der
Software auf mehr als einem Ihrer kompatiblen Einzelplatzrechnern oder Workstations installieren
und verwenden, wenn Sie eine Named-User-Lizenz erworben haben. Vorbehaltlich der
Beschränkungen gemäß den Abschnitten 1(d) und 1(e) darf die Software gleichzeitig im Netzwerk
verwendet werden. Die maximale Zahl an Computern und/oder Benutzern sowie die Art der
Lizenz, d.h. Einzelplatzlizenz, Named-User-Lizenz oder Parallellizenz, wird beim Kauf der
Software festgelegt und genau angegeben. Einzelplatzlizenzen sind als fixe Lizenzen und nicht
als Parallellizenzen zu verwenden, d.h. es ist nicht erlaubt, die Software auf einem Rechner zu
deinstallieren, um sie auf einem anderen Rechner zu installieren und die Sofware anschließend
© 2016 Altova GmbH
Altova UModel 2017
474
Lizenzinformationen
wieder zu deinstallieren und wieder auf dem ursprünglichen Rechner zu installieren. Die
Installation sollte statisch sein. Dessen ungeachtet ist die Deinstallation und Neuinstallation in
einigen eingeschränkten Fällen, z.B. wenn ein Mitarbeiter das Unternehmen verlässt oder wenn
ein Rechner ausgemustert wird, gestattet. Während des Evaluierungszeitraums (wie nachfolgend
definiert) darf die Software nur von einem Benutzer und auf nur einem (1) Einzelplatzrechner oder
einer Workstation installiert und genutzt werden. Wenn Sie die Lizenz im Rahmen eines Pakets
von Altova-Softwareprodukten („Produktpaket“) erworben haben, von denen Sie nicht jedes
Produkt einzeln installiert haben, gelten die Bestimmungen dieses Vertrags für die Verwendung
der gesamten Software, die im Lieferumfang des Produktpakets enthalten ist.
(ii) Wenn Sie eine Lizenz für SchemaAgent erworben haben, dann gelten die
Bestimmungen dieses Lizenzvertrags zur Nutzung der Software für den darin inkludierten
SchemaAgent-Server („SchemaAgent-Server“). Dabei dürfen Sie den SchemaAgent-Server jedoch
ausschließlich in Verbindung mit der Altova-Software und nur für die in der dazugehörigen
Dokumentation beschriebenen Zwecke verwenden.
(iii) Wenn Sie eine Lizenz für Software erworben haben, die es dem Benutzer ermöglicht
den Quellcode zu generieren, dann sind Sie durch die Ihnen im Rahmen dieser Lizenz erteilte
Genehmigung zur Installation und Verwendung der Software auch berechtigt, den Quellcode zu
generieren, und zwar (i) anhand von Modulen der Altova Library, die in der Software inkludiert sind
(der auf diese Weise generierte Code wird als „beschränkter Quellcode“ bezeichnet), und (ii)
anhand Ihrer eigenen Schemata oder Mappings (der anhand Ihres eigenen Quellmaterials
generierte Code wird als „unbeschränkter Quellcode“ bezeichnet). Zusätzlich zu den durch diesen
Lizenzvertrag eingeräumten Rechten gewährt Ihnen Altova eine nicht ausschließliche, nicht
übertragbare und eingeschränkte Lizenz, den gesamten generierten Code (bestehend aus dem
beschränkten und unbeschränkten Quellcode) in eine ausführbare Objektcodeform zu übersetzen
und diese zu verwenden, zu kopieren, weiterzugeben oder zu lizenzieren. Sie sind nur dann
befugt, den beschränkten Quellcode in unkompilierter Form ab- oder weiterzugeben,
weiterzulizenzieren, zu verkaufen oder an Dritte zu übertragen, wenn die betreffende Partei bereits
in Form eines gesonderten Lizenzvertrags mit Altova zur Verwendung des beschränkten
Quellcodes berechtigt ist. Ungeachtet anderslautender Bestimmungen in diesem Lizenzvertrag
dürfen Sie die Altova-Library-Module oder den beschränkten Quellcode (oder sonstiges geistiges
Eigentum von Altova enthalten in oder in Verbindung mit den Altova- Library-Modulen oder dem
beschränkten Quellcode) nicht in solcher Art und Weise weitergeben, in andere Software
einbetten, mit anderer Software verbinden oder auf andere Weise verwenden, die den
beschränkten Quellcode den Bestimmungen des „Copylefts“, der freien Software oder einer Open
Source Lizenz unterwerfen würde, welche die Offenlegung des beschränkten Quellcodes oder der
Altova-Library- Module erforderlich machen würde. Ungeachtet anderslautender Bestimmungen in
diesem Lizenzvertrag dürfen Sie die Software nicht verwenden, um ohne vorherige schriftliche
Einwilligung von Seiten Altovas andere Software-Programme zu entwickeln und zu vertreiben, die
eine direkte Konkurrenz zu Altova-Software oder einem Altova-Dienst darstellen. Altova behält
sich alle übrigen Rechte an der Software vor. Bei den Bestandteilen von UModel, für die ein
Reverse Engineering Ihres eigenen oder eines anderen Quellcodes, den Sie rechtmäßig erworben
haben, zulässig ist, stellt eine solche Verwendung durch Sie keinen Verstoß gegen diesen
Lizenzvertrag dar. Soweit dies nicht in Abschnitt 1(j) ausdrücklich gestattet wird, ist ein Reverse
Engineering der Software explizit untersagt.
(iv) Falls beschränkter Quellcode in Form ausführbaren Objektcodes inkludiert wird,
verpflichten Sie sich, folgende Informationen (1) in den Willkommensbildschirm, oder falls nicht
vorhanden, in einen oder mehrere der durch den Endbenutzer jederzeit aufrufbaren Bildschirme
und (2) - in elektronischer und/oder gedruckter Form in die Dokumentation zu inkludieren: "Teile
dieses Programms wurden unter Verwendung von Altova® [Name der Altova Software, z.B.
MapForce® 2016] entwickelt und enthalten Bibliotheken, die im Eigentum der Altova GmbH
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
475
(Copyright © 2007-2016 Altova GmbH (www.altova.com) stehen."
(b)
Verwendung auf einem Server zur Installation und Verwendung von
SchemaAgent. Sie sind berechtigt, ein (1) Exemplar der Software auf einem Dateiserver
ausschließlich innerhalb Ihres internen Netzwerks zu installieren und von dort auf die maximale
Zahl von betrieblich genutzten Computern innerhalb dieses Netzwerks, die in der Lizenz
angegeben ist, herunterzuladen und zu installieren. Wenn Sie eine Lizenz für SchemaAgent
erworben haben, können Sie SchemaAgent auf jedem Server oder jeder Workstation installieren
und in Verbindung mit Ihrer Software verwenden. Jede sonstige Netzwerknutzung ist unzulässig;
dies umfasst insbesondere die direkte Verwendung oder die Nutzung der Software über Befehle,
Daten oder Anweisungen von oder an einen Computer, der nicht Teil Ihres internen Netzwerks ist,
die Verwendung für Internet- oder Webhosting-Dienste sowie die Verwendung durch einen
Benutzer, der nicht unter einer gültigen Lizenz von Altova zur Verwendung dieses Exemplars der
Software berechtigt ist.
(c)
Benutzerdefinierte Nutzung. Wenn Sie eine Lizenz der „benutzerdefinierten Version“
der Software erworben haben, sind Sie berechtigt, die Software auf bis zu fünf (5) kompatiblen
Einzelplatzrechnern oder Workstations zu installieren, auf denen Sie der primäre Nutzer sind.
Dadurch können Sie von einem Computer zu einem anderen je nach Bedarf wechseln,
vorausgesetzt, dass die Software von Ihnen als benutzerdefinierter Nutzer jeweils nur ein (1) Mal
gleichzeitig verwendet wird. Wenn Sie mehrere benutzerdefinierte Lizenzen erworben haben,
erhält jeder individuell definierte Nutzer einen gesonderten Lizenzschlüssel.
(d)
Parallellizenz für die Verwendung im selben LAN (Local Area Network). Wenn
Sie eine Parallellizenz Software-Version erworben haben, können Sie die Software auf mehreren
kompatiblen und betrieblich genutzten Computern installieren, jedoch höchstens zehnmal (10mal) die maximale Anzahl der Benutzer, vorausgesetzt, dass nur die maximale Zahl von
Benutzern die Software wirklich gleichzeitig nutzen sowie weiters vorausgesetzt, dass die
Computer, auf welchen die Software installiert ist, in dasselbe LAN (Local Area Network)
eingebunden sind. Die maximale Zahl der Parallelbenutzer wird beim Kauf der Software festgelegt.
Sofern die Parallelbenutzer Version der Software an mehr als einem Standort oder in mehr als
einem Netzwerk verwendet werden soll, sind für jedes separate LAN (Local Area Network)
separate Parallelbenutzerlizenzen erforderlich, wobei die Einschränkungen hinsichtlich der
maximalen Zahl der Benutzer und der Anzahl der Nutzer, die die Software benutzen, anwendbar
sind. Für den Fall, dass ein Computer nicht in dasselbe LAN (Local Area Network) eingebunden
ist, ist für diesen eine lokal installierte Benutzerlizenz oder eine Parallellizenz für die Verwendung
in einer virtuellen Umgebung erforderlich.
(e)
Parallellizenz für die Verwendung in einer virtuellen Umgebung. Wenn Sie eine
Parallellizenz erworben haben, sind Sie berechtigt, ein Exemplar der Software auf einem einzigen
Terminalserver
(Microsoft
Terminal
Server
oder
Citrix
Metaframe),
einem
Anwendungsvirtualisierungsserver (Microsoft App-V, Citrix XenApp oder VMWare ThinApp) oder
einer virtuellen Maschine in Ihrem Intranet zu installieren, damit einzelne Benutzer in Ihrer
Organisation von einem anderen Computer über einen
Terminalserver,
einen
Anwendungsvirtualisierungsserver oder eine virtuelle Maschine auf die Software zugreifen und
diese nutzen können. Jedoch darf die Zahl der Benutzer, die über einen solchen Netzwerk- oder
Terminalserver bzw. eine virtuelle Maschine zum selben Zeitpunkt auf die Software zugreifen, die
maximale Zahl der im Lizenzumfang enthaltenen User nicht überschreiten. Außerdem darf die
Gesamtanzahl der Benutzer, die die Software über den Terminal Server, den
Anwendungsvirtualisierungsserver oder eine virtuelle Maschine verwenden, die zehn (10)-fache
Anzahl der lizenzierten Benutzer nicht übersteigen. Parallellizenz-Freischaltcodes können nicht
auf mehr als einem Host Terminal Server, Anwendungsvirtualisierungsserver oder einer virtuellen
Maschine bereitgestellt werden. Sie müssen mit Hilfe geeigneter Maßnahmen sicherstellen,
© 2016 Altova GmbH
Altova UModel 2017
476
Lizenzinformationen
dass nicht mehr als die maximale Anzahl der in der Lizenz vorgesehenen Benutzer gleichzeitig
auf die Software zugreifen. Altova gibt über die Performance der Altova-Software in einer
Umgebung, in der Terminalserver oder virtuelle Maschinen verwendet werden, keinerlei
Zusicherungen oder Gewährleistungen ab. Die Anwendung der Altova-Software auf die vorstehend
beschriebene Weise ist ausdrücklich von der eingeschränkten Garantie, die durch Abschnitt 5
dieses Lizenzvertrags eingeräumt wird, ausgeschlossen. Ebenso wird kein technischer Support
bei Problemen geleistet, die aufgrund der Anwendung in einer solchen Umgebung auftreten.
(f)
Kopien für Sicherungs- und Archivierungszwecke. (iii) Sie dürfen eine (1) Kopie der
Software für Sicherungs- und eine Kopie für Archivierungszwecke herstellen, sofern diese nicht auf
einem Computer installiert oder verwendet werden. Außerdem müssen bei Kopien zu Sicherungsund Archivierungszwecken alle im Original enthaltenen urheber- und patentrechtlichen Angaben
sowie alle anderen Angaben hinsichtlich geistiger Eigentumsrechte von Ihnen reproduziert werden
und in der jeweiligen Kopie der Software unverändert enthalten sein. Die Befugnis zum Anlegen
einer Sicherungs- und Archivierungskopie darf nur an Dritte übertragen werden, wenn gleichzeitig
eine Übertragung aller Rechte an der Software gemäß Abschnitt 3 erfolgt.
(g)
Freischaltcodes, Upgrades und Updates. Bevor Sie die Software kaufen bzw. im
Rahmen Ihrer Registrierung für den Evaluierungszeitraum von dreißig (30) Tagen erhalten Sie
einen Evaluierungs-Freischaltcode. Wenn Sie sich in der Folge dazu entscheiden, die Software
von Altova GmbH oder einem autorisierten Vertriebshändler zu kaufen, erhalten Sie einen
uneingeschränkten Freischaltcode. Mit diesem können Sie die Software nach dem
Evaluierungszeitraum aktivieren. Ohne ausdrückliche schriftliche Genehmigung von Altova dürfen
Sie an Freischaltcodes keine Lizenzen einräumen und Freischaltcodes nicht reproduzieren oder
vertreiben. Wenn die von Ihnen in Lizenz erworbene Software ein Upgrade oder Update ist, ersetzt
das Upgrade oder Update das sie zuletzt heruntergeladen oder installiert haben, die zuvor
lizenzierte Kopie der Software. Durch das betreffende Upgrade oder Update und den
dazugehörigen Freischaltcode wird keine zweite Lizenz für die Software gewährt, und Sie dürfen
die Kopie des Upgrades oder Updates nicht zusätzlich zu der Kopie der Software verwenden, die
dadurch ersetzt wird und dessen Lizenz beendet wurde.
(h)
Eigentumsrecht. Das Eigentumsrecht an der Software wird Ihnen nicht übertragen. Alle
Exemplare der Software und alle von Ihnen angefertigte Kopien verbleiben – vorbehaltlich der Ihnen
durch diesen Vertrag eingeräumten Rechte – im Eigentum von Altova. Dokumente, Dateien,
Stylesheets, generierter Programmcode (dies beinhaltet auch den unbeschränkten Quellcode)
und Schemata, die Sie unter Verwendung der Software anlegen oder erstellen, sind in
Übereinstimmung mit der dazugehörigen Dokumentation und den Bestimmungen dieses Vertrags
Ihr Eigentum außer diese wurden mit einer Testsoftware gemäß Abschnitt 4 dieser Vereinbarung
erstellt. In diesem Fall wird Ihnen nur eine beschränkte Lizenz zur Nutzung sämtlicher
Ergebnisse, welche einen generierten Programmcode (inklusive eines unbeschränkten
Quellcodes) enthalten, wie Java, C++, C#, VB.NET oder XSLT und verbundene Projektdateien und
Build Scripts sowie generierte XML, XML Schematas, Dokumentationen, UML Diagrammen und
Datenbankstrukturen, für die 30 Tage dauernde Testperiode eingeräumt.
(i)
Reverse Engineering. Sofern dies nicht ausdrücklich nach geltendem Recht der
Europäischen Union gestattet ist, sind Sie nicht berechtigt, an der Software Reverse Engineering
durchzuführen, die Software zu dekompilieren, zu disassemblieren, oder auf andere Weise zu
versuchen, den Quellcode, zugrunde liegende Konzepte, Techniken für Benutzerschnittstellen
oder Algorithmen der Software direkt oder indirekt zu entschlüsseln. Davon ausgenommen ist
lediglich das ausdrücklich nach geltendem Recht der Europäischen Union gestattete Maß an
Dekompilierung, das erforderlich ist, um die Funktionsfähigkeit der Software mit anderen
Softwareprogrammen zu erzielen. Dies ist Ihnen jedoch erst dann gestattet, wenn Sie zuerst bei
Altova die dafür notwendigen Informationen angefordert haben und Altova Ihnen diese nicht zur
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
477
Verfügung gestellt hat. Altova ist berechtigt, für die Bereitstellung solcher Informationen
angemessene Bedingungen aufzustellen und eine angemessene Entschädigung zu verlangen. Die
von Altova zur Verfügung gestellten Informationen bzw. alle von Ihnen im Sinne der hier
festgelegten Bestimmungen rechtmäßig erworbenen Informationen dürfen nur zu den hierin
angeführten Zwecken verwendet und keinesfalls an Dritte weitergegeben oder zur Entwicklung von
Software genutzt werden, die der Software, die Gegenstand dieses Lizenzvertrags ist, in
wesentlichen Aspekten ähnlich ist. Informationen im Sinne dieses Absatzes können von
Benutzern aus der Europäischen Union bei der Kundendienstabteilung von Altova angefordert
werden.
(j)
Sonstige Beschränkungen. Sie sind nicht berechtigt, die Software (zur Gänze oder
teilweise) zu verleihen, zu vermieten, per Leasing zur Verfügung zu stellen, weiterzulizenzieren,
weiterzugeben oder auf sonstige Weise Dritten zu überlassen, es sei denn, dies ist durch die
Bestimmungen in Abschnitt 3 oder an anderer Stelle in diesem Lizenzvertrag ausdrücklich
gestattet. Sofern dies nicht ausdrücklich in diesem Vertrag gestattet ist, dürfen Sie die Software
nicht kopieren. Alle Kopien, zu deren Anfertigung Sie berechtigt sind, müssen die im Original
enthaltenen urheber- und patentrechtlichen Angaben sowie alle anderen Angaben hinsichtlich
geistiger Eigentumsrechte unverändert enthalten. Die Software darf nicht verändert, adaptiert oder
übersetzt werden. Sie dürfen weder direkt noch indirekt ein Pfand- oder Sicherungsrecht an der
Software bestellen oder die Bestellung eines solchen zulassen. Es ist Ihnen nicht gestattet,
wissentlich eine Handlung vorzunehmen, durch die die Software öffentlich zugänglich wird, oder
die Software in einer Computerumgebung zu verwenden, die nicht in diesem Vertrag angegeben
ist. Die Verwendung oder der Zugriff auf die Software durch Dritte im Zusammenhang mit einer
kommerziellen Dienstleistung wie z.B. für eine Cloud-basierte oder webbasierte SaaSVerwendung ist nicht gestattet.
Sie haben die geltenden gesetzlichen Bestimmungen und die Anweisungen von Altova in
Bezug auf die Benutzung der Software einzuhalten. Sie sind verpflichtet, Ihre Mitarbeiter und
Vertreter, die Zugriff auf die Software haben, von den in diesem Vertrag enthaltenen
Beschränkungen in Kenntnis zu setzen und diese auf sie zu überbinden.
(k)
KEINE GARANTIE. ES WIRD KEINE GARANTIE ODER GEWÄHRLEISTUNG FÜR DIE
FEHLERFREIHEIT DER SOFTWARE ABGEGEBEN ODER GEWÄHRT UND VON ALTOVA
KEINERLEI
HAFTUNG
DIESBEZÜGLICH
ÜBERNOMMEN.
UNABHÄNGIG
VON
IRGENDWELCHEN SUPPORTLEISTUNGEN NACH IRGENDEINEM TECHNISCHEN STANDARD
IST DIE SOFTWARE KEINESFALLS FÜR DIE VERWENDUNG IN ODER IM ZUSAMMENHANG
MIT KERNKRAFTANLAGEN, FLUGGERÄTENAVIGATION, KOMMUNIKATIONSSYSTEMEN
ODER LUFTVERKEHRSKONTROLLEINRICHTUNGEN, MEDIZINISCHEN GERÄTEN ODER
LEBENSERHALTUNGSSYSTEMEN, MEDIZINISCHEN ODER DIE GESUNDHEITSVORSORGE
BETREFFENDEN ANWENDUNGEN, ODER SONSTIGEN ANWENDUNGEN KONZIPIERT, BEI
DENEN FEHLER DER SOFTWARE ODER FEHLER BEI DER DATENVERARBEITUNG ZU
TODESFÄLLEN, PERSONENSCHÄDEN ODER SCHWEREN SACH- ODER UMWELTSCHÄDEN
FÜHREN KÖNNTEN. SIE ERKLÄREN SICH DAMIT EINVERSTANDEN, DASS SIE DIE
ALLEINIGE VERANTWORTUNG FÜR DIE EIGNUNG UND ZWECKMÄSSIGKEIT DER
SOFTWARE UND ALLE MIT DER SOFTWARE ERSTELLTEN ODER VERARBEITETEN DATEN
FÜR DEN BEABSICHTIGTEN VERWENDUNGSZWECK TRAGEN UND SIE WERDEN ALTOVA
UND DEREN GESCHÄFTSFÜHRER SOWIE ANGESTELLTE HINSICHTLICH ALLER
ANSPRÜCHE, FORDERUNGEN UND KLAGEN DRITTER, DIE AUF DIE EIGNUNG UND
ZWECKMÄSSIGKEIT DER VON IHNEN VERWENDETEN SOFTWARE ODER DIE VON DER
SOFTWARE ERSTELLTEN DATEN GEGRÜNDET SIND, SCHAD- UND KLAGLOS HALTEN.
2. GEISTIGE EIGENTUMSRECHTE
© 2016 Altova GmbH
Altova UModel 2017
478
Lizenzinformationen
Die Software und alle Kopien, deren Anfertigung Ihnen von Altova gestattet ist, sind das geistige
Eigentum von Altova und dessen Lieferanten und stehen in deren Besitz. Struktur, Organisation
und Code der Software stellen wertvolle Betriebsgeheimnisse und vertrauliche Informationen von
Altova und dessen Lieferanten dar. Die Software ist durch gesetzliche Bestimmungen
urheberrechtlich geschützt. Diese gesetzlichen Bestimmungen beinhalten (ohne darauf
beschränkt zu sein) das Urheberrecht der Vereinigten Staaten, internationale Verträge und das in
den Ländern, in denen die Software genutzt wird, geltende Recht. Sie anerkennen, dass sich
Altova das Eigentum an allen Patenten, Urheberrechten, Branchengeheimnissen, Warenzeichen
und sonstigen geistigen Eigentumsrechten, die hinsichtlich der Software bestehen, vorbehält. Das
Eigentumsrecht von Altova erstreckt sich auch auf alle Bilder, Fotografien, Animationen, Videos,
Audioaufzeichnungen, Musikstücke, Texte und „Applets“, die Teil der Software sind, und alle
dazugehörigen Unterlagen in gedruckter Form. Sie dürfen keine Handlungen vornehmen, die sich
nachteilig auf die geistigen Eigentumsrechte von Altova an der Software auswirken. Warenzeichen
dürfen nur in Übereinstimmung mit den anerkannten Standards für die Verwendung von
Warenzeichen (einschließlich der namentlichen Nennung der Warenzeicheninhaber) verwendet
werden. Die Verwendung von Warenzeichen ist nur zur Kennzeichnung von Druckmaterialien, die
mit der Software hergestellt wurden, gestattet. Es entstehen Ihnen daraus keinerlei
Eigentumsrechte an dem betreffenden Warenzeichen. Altova®, XMLSpy®, Authentic®,
StyleVision®,
MapForce®,
UModel®,
DatabaseSpy®,
DiffDog®,
SchemaAgent®,
SemanticWorks®, MissionKit®, Markup Your Mind®, Nanonull™, RaptorXML™, RaptorXML
Server™, RaptorXML +XBRL Server™, Powered By RaptorXML™, FlowForce Server™,
StyleVision Server™ und MapForce Server™ sind (in mehreren Ländern eingetragene oder
angemeldete) Warenzeichen der Altova GmbH. Unicode und das Logo von Unicode sind
Warenzeichen von Unicode, Inc. Windows, Windows XP, Windows Vista, Windows 7 und
Windows 8 sind Warenzeichen von Microsoft. W3C, CSS, DOM, MathML, RDF, XHTML, XML und
XSL sind (in mehreren Ländern eingetragene) Warenzeichen des World Wide Web Consortium
(W3C). Marken des W3C sind von den Dachinstitutionen des Konsortiums (MIT, INRIA und Keio)
eingetragen und stehen in deren Eigentum. Sofern dies nicht ausdrücklich hierin festgelegt ist,
entstehen Ihnen aus diesem Vertrag keinerlei geistige Eigentumsrechte an der AltovaXML
Software. Mitteilungen über geltend gemachte Verstöße gegen geistige Eigentumsrechte sind an
den Copyright Agent von Altova zu richten (nähere Angaben dazu finden Sie auf der Website von
Altova).
3. ÜBERTRAGUNGSBESCHRÄNKUNG
Ungeachtet der vorstehenden Bestimmungen dürfen Sie alle Ihre Rechte zur Verwendung der
Software an eine andere natürliche oder juristische Person unter der Voraussetzung übertragen,
dass: (a) Sie den vorliegenden Vertrag, die Software und sonstige Soft- oder Hardware, die mit der
Software, die Gegenstand dieses Vertrags ist, geliefert, verpackt oder auf dieser vorinstalliert ist,
einschließlich aller Kopien, Updates und früherer Versionen sowie aller Exemplare von
Fontsoftware, die in andere Formate konvertiert wurde, an die betreffende Person übertragen; (b)
Sie keine Kopien, einschließlich Sicherungskopien und sonstiger, auf einem Computer
gespeicherter Kopien, zurückbehalten; (c) der Empfänger von Altova einen persönlichen
Freischaltcode von Altova erhält; und (d) der Empfänger die Bestimmungen dieses Vertrags sowie
alle anderen Bestimmungen akzeptiert, zu denen Sie die Softwarelizenz rechtmäßig erworben
haben. Ungeachtet der vorstehenden Ausführungen dürfen Sie keine Schulungs-, Vorab- oder
Musterkopien der Software an Dritte übertragen.
4. ZUSÄTZLICHE BEDINGUNGEN FÜR VORAB- UND TESTVERSIONEN
Wenn es sich bei dem von Ihnen mit dieser Lizenz erworbenen Produkt um eine unverkäufliche
Vorabversion oder um Beta-Software („Pre-Release-Software“) handelt, gelten die in diesem
Abschnitt enthaltenen Bedingungen. Diese gelten außerdem für alle Test- und/oder
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
479
Demoversionen von Altova-Software („Testsoftware“) und bleiben so lange gültig, bis Sie eine
Lizenz erwerben. Wenn Bestimmungen dieses Abschnitts im Widerspruch zu anderen, in diesem
Vertrag enthaltenen Bestimmungen stehen, dann gehen die Bedingungen dieses Abschnitts
hinsichtlich Pre-Release-Software und Testsoftware allen anderen Bestimmungen dieses
Lizenzvertrags vor, soweit dies für die Auflösung des Widerspruchs erforderlich ist. Sie erkennen
an, dass es sich bei der Pre-Release-Software um eine Vorabversion handelt, die nicht das
endgültige Produkt von Altova darstellt, und in der Fehler, Funktionsstörungen oder andere
Probleme auftreten können, die möglicherweise zu einem System- oder Hardwareabsturz oder fehler bzw. zu Datenverlust führen. DIE PRE-RELEASE-SOFTWARE UND/ODER
TESTSOFTWARE WIRD IHNEN DAHER OHNE GEWÄHR FÜR DEREN VERWENDUNG ODER
LEISTUNGSMERKMALE ZUR VERFÜGUNG GESTELLT, UND ALTOVA ÜBERNIMMT
DIESBEZÜGLICH
KEINERLEI
AUSDRÜCKLICHE
ODER
STILLSCHWEIGENDE
GEWÄHRLEISTUNGS- ODER HAFTUNGSVERPFLICHTUNGEN. SOFERN UND SOWEIT FÜR
PRE-RELEASE- UND/ODER TESTSOFTWARE KEIN HAFTUNGSSAUSSCHLUSS, SONDERN
NUR EINE HAFTUNGSBESCHRÄNKUNG GESETZLICH ZULÄSSIG IST, BESCHRÄNKT SICH
DIE HAFTUNG VON ALTOVA UND DESSEN LIEFERANTEN AUF INSGESAMT FÜNFZIG USDOLLAR (50 USD). Wenn die Testversion mit einer Time-out-Funktion ausgestattet ist, kann sie
nach Ablauf des Evaluierungszeitraums nicht mehr verwendet werden. Mit dem Ablauf dieses
Zeitraums endet Ihre Lizenz automatisch, wenn Sie sie nicht verlängern. Ihre Lizenz zur Nutzung
sämtlicher mit der Testsoftware erstellten Ergebnisse, welche einen generierten Progammcode
(inklusive den unbeschränkten Quellcode) wie Java, C++, C#, VB.NET oder XSLT und verbundene
Projektdateien und Build Scripts sowie generierte XML, XML Schematas, Dokumentationen, UML
Diagramme und Datenbankstrukturen enthalten, erlischt automatisch nach Ablauf der
vorgesehenen Testperiode. Die Lizenz zum Gebrauch dieser Ergebnisse lebt nach dem Kauf einer
Lizenz für die Software, die Sie getestet und mit der Sie das Ergebnis erstellt haben, wieder auf.
Der Zugriff auf Dateien, die mit der Testsoftware erstellt wurden, erfolgt auf Ihr alleiniges Risiko.
Sie bestätigen, dass Altova Ihnen weder zugesichert noch garantiert hat, die Pre-ReleaseSoftware zu einem späteren Zeitpunkt anderen Personen anzukündigen oder zur Verfügung zu
stellen. Sie bestätigen ferner, dass Altova sich Ihnen gegenüber weder ausdrücklich noch
stillschweigend verpflichtet hat, die Pre-Release-Software öffentlich anzukündigen oder
einzuführen, und dass Altova kein Produkt anbieten muss, das der Pre-Release-Software ähnlich
oder mit ihr kompatibel ist. Sie bestätigen folglich, dass jegliche Forschungs- oder
Entwicklungsarbeit, die Sie in Bezug auf die Pre-Release-Software oder damit verbundene
Produkte ausführen, in Ihr alleiniges Risiko fällt. Wenn Altova Sie dazu auffordert, werden Sie für
die Dauer dieses Vertrags Altova Rückmeldung bezüglich Ihrer Tests und der Pre-ReleaseSoftware geben, einschließlich entsprechender Berichte über Fehler und Funktionsstörungen.
Wenn Sie die Pre-Release-Software im Rahmen einer gesonderten schriftlichen Vereinbarung
erhalten haben, unterliegt Ihre Verwendung der Software den darin enthaltenen Bedingungen. Es
ist Ihnen nicht gestattet, die Pre-Release-Software unterzulizenzieren, per Leasing zur Verfügung
zu stellen, zu verleihen, zu vermieten, weiterzugeben oder auf sonstige Weise Dritten zu
überlassen. Sie verpflichten sich, bei Erhalt einer späteren unveröffentlichten Version der PreRelease-Software bzw. bei Erhalt einer kommerziellen Vollversion von Altova (entweder als
Einzelprodukt oder als Teil eines Gesamtprodukts) die zuvor von Altova erhaltene Pre-ReleaseSoftware zurückzugeben oder zu vernichten und den Bestimmungen des Lizenzvertrags für die
betreffende spätere Version der Pre-Release-Software Folge zu leisten.
5. EINGESCHRÄNKTE GARANTIE UND HAFTUNGSBESCHRÄNKUNG
(a)
Eingeschränkte Garantie und Garantieansprüche der Kunden. Altova garantiert der
Person/Rechtspersönlichkeit, die ursprünglich die Lizenz für die Verwendung der Software gemäß
den Bestimmungen dieses Vertrags erworben hat, dass (i) die Software über einen Zeitraum von
neunzig (90) Tagen nach Erhalt im Wesentlichen in Übereinstimmung mit der dazugehörigen
Dokumentation funktioniert, und (ii) die von Altova zur Verfügung gestellten Supportleistungen im
© 2016 Altova GmbH
Altova UModel 2017
480
Lizenzinformationen
Wesentlichen auf die in Abschnitt 6 dieses Vertrags niedergelegte Weise erfolgen. In einigen
Ländern sind Beschränkungen über die Dauer einer stillschweigenden Garantie nicht zulässig, so
dass die obigen Beschränkungen und Ausschlüsse eventuell für Sie nicht zutreffen. Im
größtmöglichen rechtlich zulässigen Maß sind stillschweigende Garantien in Bezug auf die
Software (sofern solche existieren) auf neunzig (90) Tage beschränkt. Die gesamte Haftung von
Altova und dessen Lieferanten, sowie Ihre einzigen Garantieansprüche, sind nach dem Ermessen
von Altova auf eine der beiden folgenden Optionen beschränkt: (i) Erstattung des Kaufpreises
(wenn zutreffend), oder (ii) Reparatur oder Austausch der Software, die unter die eingeschränkte
Garantie von Altova fällt und die unter Vorlage einer Kopie des Kaufbelegs bei Altova reklamiert
wird. Diese eingeschränkte Garantie gilt nicht, wenn die Funktionalität der Software durch ein
Versehen, durch Missbrauch, falsche Anwendung, Trojaner, Viren oder einen sonstigen
schädlichen externen Code beeinträchtigt wurde. Die Garantie für jede Ersatzsoftware erstreckt
sich auf die Restdauer des ursprünglichen Garantiezeitraums oder auf dreißig (30) Tage, je
nachdem, welcher Zeitraum länger ist. Die eingeschränkte Garantie gilt nicht für Test- und/oder
Pre-Release-Software.
(b)
Keine weiteren Garantien, Haftungsausschluss.
MIT AUSNAHME DER
VORSTEHEND
ANGEFÜHRTEN
EINGESCHRÄNKTEN
GARANTIE
UND
DEN
DIESBEZÜGLICHEN GARANTIEANSPRÜCHEN BESTEHEN SEITENS ALTOVA ODER
DESSEN LIEFERANTEN KEINERLEI WEITEREN GARANTIEVERPFLICHTUNGEN. ALTOVA
UND DESSEN LIEFERANTEN ÜBERNEHMEN KEINE GEWÄHR FÜR DIE ANWENDUNG ODER
DIE ERGEBNISSE AUS DER NUTZUNG DER SOFTWARE. MIT AUSNAHME DER
VORSTEHEND ANGEFÜHRTEN EINGESCHRÄNKTEN GARANTIE SOWIE IM HINBLICK AUF
ALLE ANDEREN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN ODER
ANSPRÜCHE, DIE NACH DER FÜR IHR LAND GELTENDEN RECHTSORDNUNG NICHT
AUSGESCHLOSSEN ODER EINGESCHRÄNKT WERDEN KÖNNEN, SCHLIESSEN ALTOVA
UND
DESSEN
LIEFERANTEN
ALLE
ANDEREN
AUSDRÜCKLICHEN
ODER
STILLSCHWEIGENDEN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN UND
ANSPRÜCHE AUS, DIE SICH AUS DEM GESETZ, DER RECHTSPRAXIS, EINEM
GEWOHNHEITSRECHT, EINEM HANDELSBRAUCH ODER AUS SONSTIGEN GRÜNDEN
ERGEBEN. ALTOVA UND DESSEN LIEFERANTEN SCHLIESSEN IM GRÖSSTMÖGLICHEN
RECHTLICH ZULÄSSIGEN UMFANG ALLE ANDEREN AUSDRÜCKLICHEN UND
STILLSCHWEIGENDEN GARANTIEN UND GEWÄHRLEISTUNGEN AUS. DIES BEINHALTET
UNTER ANDEREM GARANTIEN IM HINBLICK AUF MARKTGÄNGIGKEIT, EIGNUNG FÜR
EINEN BESTIMMTEN ZWECK, ZUFRIEDENSTELLENDE QUALITÄT, INFORMATIONSGEHALT
ODER
–RICHTIGKEIT,
UNGESTÖRTE
NUTZUNG,
EIGENTUMSRECHT
UND
NICHTVERLETZUNG VON RECHTEN DRITTER UND DIE ERBRINGUNG ODER
NICHTERBRINGUNG VON SUPPORTLEISTUNGEN IN BEZUG AUF DIE SOFTWARE. MIT
DIESER EINGESCHRÄNKTEN GARANTIE WERDEN IHNEN BESTIMMTE RECHTE
EINGERÄUMT. UNTER UMSTÄNDEN BESITZEN SIE NOCH ANDERE RECHTE; DIE JA NACH
LAND/RECHTSORDNUNG UNTERSCHIEDLICH SEIN KÖNNEN.
(c)
Haftungseinschränkung. SOWEIT DIE ANWENDBAREN GESETZE DIES ZULASSEN,
HAFTEN ALTOVA ODER DESSEN LIEFERANTEN, AUCH WENN EINE IM RAHMEN DER
GARANTIE DURCHGEFÜHRTE ABHILFEMASSNAHME IHREN WESENTLICHEN ZWECK
NICHT ERFÜLLT, IN KEINEM FALL FÜR KONKRETE, ZUFÄLLIG ENTSTANDENE,
MITTELBARE, UNMITTELBARE ODER FOLGESCHÄDEN JEGLICHER ART (INSBESONDERE
SCHÄDEN AUS ENTGANGENEM GEWINN, GESCHÄFTSUNTERBRECHUNGEN, VERLUST
VON GESCHÄFTSINFORMATIONEN ODER ANDEREN FINANZIELLEN VERLUSTEN), DIE
DURCH DIE NUTZUNG ODER DIE UNMÖGLICHKEIT DER NUTZUNG DER SOFTWARE ODER
DIE NICHTERBRINGUNG VON SUPPORTLEISTUNGEN ENTSTANDEN SIND, SELBST WENN
ALTOVA AUF DIE MÖGLICHKEIT EINES SOLCHEN SCHADENS HINGEWIESEN WURDE. IIN
JEDEM FALL IST DIE GESAMTHAFTUNG VON ALTOVA GEMÄSS DIESEM VERTRAG AUF
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
481
DIE HÖHE DES FÜR DAS SOFTWAREPRODUKT ENTRICHTETEN BETRAGES BESCHRÄNKT.
Da es in einigen Ländern und Rechtsordnungen nicht zulässig ist, die Haftung für Schäden
auszuschließen oder zu beschränken, gilt die obige Einschränkung unter Umständen nicht für
Sie. In solchen Ländern und Rechtsordnungen gilt die Beschränkung der Haftung durch Altova im
größtmöglichen rechtlich zulässigen Umfang, und der Ausschluss bzw. die Beschränkung der in
diesem Lizenzvertrag beinhalteten Garantien und Haftungen hat keine Auswirkung auf die
Konsumentenschutzrechte von Personen, die Waren auf andere Weise als im Zuge ihrer
geschäftlichen Tätigkeit erwerben. Der vorstehende Haftungssauschluss/die vorstehende
Haftungsbeschränkung sind wesentliche Bestandteile des zwischen Ihnen und Altova
abgeschlossenen Vertrags.
(d)
Ansprüche in Zusammenhang mit Urheberrechtsverletzungen. Altova wird Sie
gegenüber allen Forderungen, Prozessen oder Verfahren schad- und klaglos halten bzw. alle
Ansprüche, Prozesse oder Verfahren beilegen, die Dritte mit dem Argument gegen Sie erheben,
dass der Inhalt der Software gegen ein Urheberrecht verstößt oder ein geistiges oder sonstiges
Eigentumsrecht verletzt, das durch das Recht der Vereinigten Staaten oder der Europäischen
Union geschützt ist (insgesamt als „Ansprüche“ bezeichnet). Dies erfolgt – soweit nicht
ausdrücklich etwas Anderes festgelegt ist – jedoch nur insoweit, als der betreffende Anspruch
sich direkt aus der Verwendung der Software ergibt und nach Maßgabe der in Abschnitt 5 dieses
Vertrags festgelegten Beschränkungen. Altova ist von jedem Anspruch innerhalb von zehn (10)
Geschäftstagen, nachdem Sie erstmals davon benachrichtigt wurden, in Kenntnis zu setzen.
Außerdem haben Sie mit Altova in angemessenem Umfang bei der Abwehr solcher Ansprüche zu
kooperieren und Altova dabei zu unterstützen, ohne dass Sie dafür Kosten geltend machen
können. Das Recht auf Entscheidungen in Bezug auf solche Ansprüche liegt allein bei Altova
(dies beinhaltet auch, ohne darauf beschränkt zu sein, die Auswahl der Rechtsberater und das
Recht, für Sie einen Vergleich zu den von Altova für zweckmäßig erachteten Bedingungen
einzugehen). Sie können auf eigene Kosten einen Rechtsberater hinzuziehen und an den
Verfahrens- oder Vergleichsverhandlungen teilnehmen. Altova kommt bis zu einer Höhe von
insgesamt maximal dem Kaufpreis der Software für die Schäden, Kosten und Anwaltsgebühren
auf, zu deren Bezahlung Sie in Zusammenhang mit solchen Ansprüchen verpflichtet werden (oder
die Sie aufgrund eines Vergleichs zu entrichten haben), soweit diese nicht von einer Versicherung
oder dritten Partei übernommen werden. Ist oder wird die Software Gegenstand von aufgrund einer
Urheberrechtsverletzung vorgebrachten Ansprüchen, oder wird ihre Verwendung untersagt, oder ist
es nach Ansicht des Rechtsberaters von Altova wahrscheinlich, dass ein solcher Umstand eintritt,
so wird Altova versuchen, eine Beilegung herbeizuführen, indem alle wirtschaftlich vertretbaren
Anstrengungen unternommen werden, um die Software zu modifizieren oder eine Lizenz für die
weitere Verwendung der Software zu erwerben. Wenn es nach Ansicht des Rechtsberaters von
Altova nicht möglich ist, den bevorstehenden oder bereits vorgebrachten Anspruch bzw. die
Verfügung, mit der die Verwendung der Software untersagt wurde, durch angemessene
Abänderung oder den Erwerb einer Lizenz beizulegen, so kann Altova diesen Vertrag ohne
negative Konsequenzen für Altova beenden und Ihnen anteilig alle bereits an Altova entrichteten
Gebühren zurückerstatten. MIT AUSNAHME DER VORSTEHEND ANGEFÜHRTEN
BESTIMMUNGEN OBLIEGEN ALTOVA KEINERLEI HAFTUNGSVERPFLICHTUNGEN FÜR
ANSPRÜCHE IN ZUSAMMENHANG MIT URHEBERRECHTSVERLETZUNGEN. Diese
Haftungsverpflichtung gilt nicht in Fällen, in denen die Urheberrechtsverletzung, ob patentrechtlich
oder anderweitig, infolge einer Kombination der Altova-Software mit zusätzlich von Ihnen
bereitgestellten Elementen verursacht wurde.
6. SUPPORT UND WARTUNG
Zusätzlich zu der Version des Softwareprodukts, für das Sie eine Lizenz erhalten haben, bietet
Altova eine Reihe von optionalen „Support- & Wartungspaketen“ („Software & Maintenance
Package“, „SMP“) an, die Sie zusätzlich zu Ihrer Lizenz für die Software erwerben können. Der für
© 2016 Altova GmbH
Altova UModel 2017
482
Lizenzinformationen
das jeweilige SMP geltende Supportzeitraum (wie nachfolgend definiert) wird beim Kauf des SMP
festgelegt. Die Support- und Wartungsservices und die Upgrades, die Ihnen zur Verfügung stehen,
hängen davon ab, ob Sie ein SMP erwerben bzw. für welche Version des SMP Sie sich
entscheiden.
(a)
Wenn Sie kein SMP erwerben, erhalten Sie beim Kauf lediglich die Software, danach
jedoch keinerlei Wartungsreleases oder Updates. Obwohl die Möglichkeit besteht, dass Altova
Ihnen in Einzelfällen Wartungsreleases als kostenlose Zusatzleistung zur Verfügung stellt, sind in
diesen Releases keine neuen Produktfeatures, die über das beim Kauf der Software bestehende
Maß hinausgehen, beinhaltet. In jedem Fall erhalten Sie dreißig (30) Tage lang ab Kauf der
Software (der „Supportzeitraum” im Sinne dieses Absatzes 6(a)) kostenlosen technischen
Support von Altova. Außerdem kann Altova in Einzelfällen auch während des dreißig (30) Tage
dauernden Evaluierungszeitraums technischen Support als kostenlose Zusatzleistung zur
Verfügung stellen. Technischen Support erhalten Sie ausschließlich über ein webbasiertes
Supportformular, wobei es keine garantierte Reaktionszeit gibt.
(b)
Mit dem Erwerb eines SMP haben Sie während des dafür geltenden Supportzeitraums
Anspruch auf die von Ihnen erworbene Produktversion sowie auf alle Wartungsreleases und
Updates für diese Produktversion, die während des für Sie geltenden Supportzeitraums
freigegeben werden. Während des Supportzeitraums Ihres SMP erhalten Sie auch Upgrades auf
die entsprechende Produktversion der Software, mit der auf eine höhere Version der Software, für
die Sie die Lizenz erworben haben, gewechselt wird und die während Ihres Supportzeitraums
freigegeben werden. Die einzelnen Upgradeeditionen, auf die Sie innerhalb Ihres Supportzeitraums
Anspruch haben, sind in dem von Ihnen erworbenen SMP im Detail angeführt. Software, die als
gesondertes Produkt eingeführt wird, ist nicht im SMP enthalten. Wartungsreleases, Updates und
Upgrades können neue Features enthalten, dies muss aber nicht der Fall sein. Darüber hinaus
erhalten Sie während des Supportzeitraums bevorzugten technischen Support von Altova, und
zwar ausschließlich über ein webbasiertes Supportformular. Altova wird alle wirtschaftlich
vertretbaren Anstrengungen unternehmen, um alle Anfragen per E-Mail innerhalb von
achtundvierzig (48) Stunden während der Geschäftszeiten (Montag bis Freitag, 8.00 bis 22.00 Uhr
UTC, ausgenommen Feiertage in Österreich und den USA) zu beantworten. Außerdem wird
Altova sich in angemessenem Umfang darum bemühen, Workarounds für Fehler, die bei der
Software aufgetreten sind, zur Verfügung zu stellen.
Während des Supportzeitraums können Sie Altova Fehler oder Defekte in der Software melden.
Wenn nach Altovas Einschätzung ein reproduzierbarer schwerwiegender Fehler vorliegt, der die
Verwendung und Funktionalität der Software erheblich beeinträchtigt, wird Altova wirtschaftlich
vertretbaren Anstrengungen unternehmen um Korrekturen oder provisorische Lösungen
anzubieten, die in zukünftigen Updates oder Wartungsreleases enthalten sind. Diese Updates
oder Wartungsreleases werden von Altova von Zeit zu Zeit zur Verfügung gestellt.
Es steht im Ermessen von Altova, einen schriftlichen Nachweis über von Ihnen festgestellte Fehler
oder Funktionsstörungen zu verlangen oder Beispieldateien anzufordern, aus denen das
aufgetretene Softwareproblem hervorgeht. In einem solchen Fall müssen Sie die angeforderten
Nachweise oder Dateien, aus denen ausreichend detailliert hervorgeht, in welchen Aspekten
Fehler bei der Software auftreten, so schnell wie möglich per E-Mail, Fax oder Expresspost mit
Zustellung am nächsten Tag an Altova übermitteln. Bei der Diagnose oder Analyse von Fehlern
haben Sie in zumutbarem Rahmen mit Altova zu kooperieren. Fehlerbehebungen können in
Wartungsreleases, Updates oder neuen Hauptversionen der Software enthalten sein. Altova ist
nicht verpflichtet, unwesentliche Fehler, d.h. Fehler, die die Benutzung der Software nach dem
Ermessen von Altova nicht wesentlich beeinträchtigen, zu beheben. Sie erhalten von Altova unter
keinen Umständen Beratung, Unterstützung oder Hilfestellung, die allgemeiner Natur ist und nicht
in unmittelbarem Zusammenhang mit der Software steht.
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
483
Bei der Aktualisierung der Software kann es unter Umständen vorkommen, dass vor der
Installation auch Software aktualisiert werden muss, die nicht unter diesen Vertrag fällt. Für
Updates von Betriebssystem- und Anwendungssoftware, die nicht ausdrücklich Gegenstand
dieses Vertrags ist, sind ausschließlich Sie verantwortlich. Solche Updates sind nicht im Umfang
dieser Lizenz enthalten und werden nicht von Altova zur Verfügung gestellt. Die Erfüllung der in
diesem Abschnitt 6 festgelegten Verpflichtungen durch Altova versteht sich unter der Bedingung,
dass Sie die Software ordnungsgemäß verwenden und diesen Vertrag ausnahmslos jederzeit
einhalten. Altova ist nicht verpflichtet, technischen Support zu leisten, wenn nach Ansicht von
Altova die Fehlfunktion der Software auf einen der folgenden Gründe zurückzuführen ist: (i) Fehler,
die durch die Verlegung der Software auf einen anderen Rechner oder Speicherort hervorgerufen
werden; (ii) Änderungen, Modifikationen oder Versuche, die Software abzuwandeln, die von Altova
nicht schriftlich genehmigt wurden; (iii) äußere Einflüsse auf die Software, wie z.B.
Naturkatastrophen, Stromausfälle, Stromschwankungen oder Computerausfälle; (iv) Ihr
Versäumnis die Software auf dem von Altova festgelegten Release Level zu halten; oder (v)
Nutzung der Software ohne vorherige Genehmigung durch Altova zusammen mit einer anderen
Software. Sie alleine sind dafür verantwortlich: (i) allen Betriebs- und Fehlerbehebungsanleitungen
von Altova Folge zu leisten, Altova unverzüglich von Fehlern oder Defekten an der Software zu
informieren und Altova eine genaue Beschreibung dieser Fehler und/oder Defekte zu liefern; (ii) für
den Schutz Ihrer vertraulichen Informationen zu sorgen; (iii) Datensicherungssysteme und -abläufe
für die Wiederherstellung verlorener oder geänderter Dateien, Daten oder Programme einzurichten
und anzuwenden.
7. AKTIVIERUNG DER SOFTWARE, UPDATES UND LIZENZÜBERWACHUNG
(a)
Lizenzzählung. Die Software enthält ein integriertes Lizenzzählungsmodul zum Zweck
der Überwachung der Einhaltung der Lizenzbestimmungen in kleinen LANs (Local Area
Networks). Dieses Lizenzzählungsmodul versucht, mit anderen Rechnern in Ihrem LAN zu
kommunizieren. Sie gestatten Altova, Ihr internes Netzwerk zu Lizenzüberwachungszwecken zu
verwenden. Dieses Lizenzzählungsmodul soll Sie zwar bei der Lizenzüberwachung unterstützen,
sollte aber nicht das einzige Mittel zu diesem Zweck darstellen. Sollte die oben genannte
Kommunikation durch Ihre Firewall-Einstellungen verhindert werden, müssen Sie eine zuverlässige
Methode implementieren, um die Verwendung der Software durch den Endbenutzer zu
überwachen und zu verhindern, dass mehr als die zulässige Anzahl an Benutzern die Software
verwendet.
(b)
Lizenzüberwachung. Sie sind verpflichtet, eine Methode oder ein Tool zu verwenden,
um sicherzustellen, dass die maximale Anzahl der Benutzer nicht überschritten wird. Sollten Sie
nicht in der Lage sein, die Verwendung der Software-Lizenzen in Ihrem Unternehmen genau
überwachen zu können, kann Ihnen Altova, ohne jedoch dadurch auf jegliche aufgrund von
Verletzungen des Vertrags entstandene Forderungen zu verzichten, zusätzliche
Lizenzüberwachungstools zur Verfügung stellen. Falls Ihnen ein solches Tool von Altova zur
Verfügung gestellt wird, sind Sie verpflichtet, es (a) zur Überwachung der Einhaltung dieses
Vertrags zu verwenden und (b) Altova die Verwendung Ihres internen Netzwerks zum Zweck der
Lizenzüberwachung und -zählung und der Generierung von Überwachungsberichten, die von Zeit
zu Zeit an Altova gesendet werden, zu gestatten.
(c)
Aktivierung der Software. Die Software kann Ihr internes Netzwerk und Ihre
Internetverbindung verwenden, um Angaben über Ihre Lizenz im Zuge der Installation,
Registrierung, Benutzung oder Aktualisierung an einen Altova Master-Lizenzserver zu
übertragen und diese zu verifizieren, um auf diese Weise eine nicht lizenzierte oder
illegale Verwendung der Software zu verhindern und den Kundenservice von Altova
weiter zu verbessern. Die Aktivierung erfolgt über einen Austausch von lizenzbezogenen
© 2016 Altova GmbH
Altova UModel 2017
484
Lizenzinformationen
Daten zwischen Ihrem Computer und dem Altova Master-Lizenzserver. Sie stimmen
dieser Vorgangsweise von Altova zu und verpflichten sich, allen diesbezüglichen
Vorgaben Folge zu leisten. Sie erklären sich damit einverstanden, dass die Verwendung
von Freischaltcodes, welche nicht von Altova erstellt werden oder wurden und nicht
rechtmäßig von Altova oder einem dazu berechtigten Wiederverkäufer erworben
wurden, zum Zweck der Aktivierung oder Nutzung der Software die gewerblichen
Schutzrechte von Altova sowie die Bestimmungen dieses Vertrages verletzt. Sie erklären
sich weiters damit einverstanden, dass Versuche mit dem Zweck der Umgehung oder
Deaktivierung
der
urheberrechtlichen
Schutzmaßnahmen,
von
Lizenzmanagementsystemen oder des Altova Master-Lizenzservers die gewerblichen
Schutzrechte von Altova sowie die Bestimmungen dieses Lizenzvertrages verletzen.
Altova behält sich ausdrücklich das Recht vor, alle rechtlich verfügbaren sowie
angemessenen Mittel zu ergreifen, um derartige Praktiken zu verhindern und
entgangenen Gewinn, Schäden und Kosten zurückerstattet zu bekommen.
(d)
LiveUpdate. Altova stellt Ihnen ein neues LiveUpdate Benachrichtigungsservice zur
Verfügung, welches kostenlos ist. Altova kann Ihr internes Netzwerk und Ihre Internetverbindung
verwenden, um Angaben über Ihre Lizenz an einen LiveUpdate-Server von Altova zu übertragen,
um Ihre Lizenz in gewissen Zeitabständen zu verifizieren und festzustellen, ob ein Update für Sie
verfügbar ist.
(e)
Verwendung von Daten Der gesamte Wortlaut der Datenschutzbestimmungen von
Altova
kann
unter
http://www.altova.com/de/privacy
eingesehen
werden.
Die
Datenschutzbestimmungen sind durch Bezugnahme Teil dieses Vertrags. Durch Ihre Zustimmung
zu den Bestimmungen dieses Vertrags bzw. durch Benutzung der Software erklären Sie sich
damit einverstanden, dass Altova für die in diesem Vertrag und/oder in den
Datenschutzbestimmungen (in der jeweils geltenden Fassung) genannten Zwecke Daten erhebt,
verarbeitet und weitergibt. Altova behält sich das Recht vor, diese Bestimmung des Vertrags und/
oder der Datenschutzbestimmungen jederzeit zu ändern. Wir legen Ihnen nahe, die auf der
Website von Altova veröffentlichten Datenschutzbestimmungen von Zeit zu Zeit erneut
durchzulesen.
(f)
Recht zur Überprüfung. Sie erklären sich damit einverstanden, dass Altova dazu
berechtigt ist, die Einhaltung der Bestimmungen dieses Vertrags jederzeit nach vorheriger
Benachrichtigung zu überprüfen. Falls sich bei der Überprüfung herausstellt, dass Sie
Bestimmungen dieses Vertrags verletzen, haben Sie zusätzlich zu allen anderen aus der
Lizenzverletzung entstehenden Haftungsansprüchen alle angemessenen Kosten, die Altova durch
die Überprüfung entstehen, zu ersetzen.
(g)
Hinweis für Benutzer in Europa. Bitte beachten Sie, dass die in Absatz 7(d)
beschriebenen Informationen von Altova, Inc., einem Unternehmen mit Sitz in Beverly,
Massachusetts, USA, oder seinen Tochterunternehmen, Zweigniederlassungen oder weltweit
ansässigen autorisierten Partnern zum Zweck der Datenverarbeitung, Analyse und Überprüfung
nach außerhalb der EU transferiert werden können. Sie werden darauf hingewiesen, dass in den
USA ein Datenschutzmodell zur Anwendung kommt, das teils auf Gesetzen, teils auf
Regierungsverordnungen und zum Teil auf Selbstregulierung beruht. Des Weiteren werden Sie
darauf hingewiesen, dass der Rat der Europäischen Union befunden hat, dass dieses
amerikanische Modell den in Artikel 25 der Datenrichtlinie der Europäischen Union (Richtlinie
95/46/EC, 1995 O.J. (L 281) 31) festgelegten Datenschutzbestimmungen nicht "in ausreichendem
Ausmaß" Rechnung trägt. Laut Artikel 26 der Datenrichtlinie der Europäischen Union, dürfen
persönliche Daten dann von der Europäischen Union in ein Drittland übertragen werden, wenn die
jeweilige Person ihre Zustimmung zur Übertragung derartiger Informationen eindeutig gegeben hat,
unabhängig davon, in welchem Ausmaß diese Daten in anderen Ländern geschützt sind. Durch
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
485
Ihre Zustimmung zu diesem Vertrag gestatten Sie die Übertragung aller derartiger Informationen
an die USA sowie deren Verarbeitung gemäß diesem Vertrag und Altovas
Datenschutzbestimmungen.
8. DAUER UND BEENDIGUNG
Dieser Vertrag wird folgendermaßen beendet: (a) indem Sie Altova eine schriftliche
Benachrichtigung von der Vertragsbeendigung übermitteln; (b) durch Altova in Form einer
diesbezüglichen schriftlichen Benachrichtigung, wenn Sie gegen diesen Vertrag verstoßen und
diesen Verstoß nicht innerhalb von 10 (zehn) Tagen, nachdem Altova Ihnen dies mitgeteilt hat,
berichtigen; oder (c) auf Verlangen eines autorisierten Vertriebshändlers von Altova, wenn Sie eine
Lizenzzahlung nicht entrichten oder sonstige Zahlungsverpflichtungen nicht einhalten. Der Vertrag
einer früheren Version der Software, für die Sie ein Upgrade oder ein Update durchgeführt haben,
wird mit Ihrer Zustimmung zu dem Vertrag, der für das Upgrade oder Update gilt, automatisch
beendet. Bei Beendigung des Vertrags dürfen Sie die gesamte Software, die Gegenstand dieses
Vertrags ist, nicht mehr verwenden, müssen alle Kopien, die in Ihrem Besitz oder Einflussbereich
stehen, vernichten, und müssen in zumutbarem Rahmen alle von Altova geforderten Maßnahmen
ergreifen, um sicherzustellen, dass keine Kopien der Software in Ihrem Besitz oder
Einflussbereich verbleiben. Die in den Abschnitten 1(h), 1(i), 1(j), 1(k), 1(l), 2, 5, 7, 9, 10, 11 und
11 niedergelegten Bestimmungen bleiben auch nach Beendigung dieses Vertrags weiterhin
aufrecht.
9. EINGESCHRÄNKTE RECHTE UND EXPORTBESCHRÄNKUNGEN
Die Entwicklung der Software wurde ausschließlich privat finanziert. Bei der Software handelt es
sich um kommerzielle Computersoftware, die mit eingeschränkten Rechten ausgestattet ist.
Die Verwendung, Vervielfältigung oder Weitergabe der Software durch die US-Regierung, eine
Behörde oder einen Kooperationspartner der US-Regierung unterliegt den Beschränkungen im
Rahmen dieses Vertrags sowie den Beschränkungen nach FAR 12.211 und 12.212 (48 C.F.R.
§12.211 und 12.212) bzw. DFARS 227.7202 (48 C.F.R. §227-7202). Dabei wird eine Lizenz für
kommerzielle Computersoftware und kommerzielle Computerdokumentation an die US-Regierung
als Endnutzer ausschließlich in Form einer Lizenz für kommerziell genutzte Güter erteilt, weshalb
es sich bei den damit verbundenen Rechten um dieselben Rechte handelt, die allen anderen
Endnutzern im Rahmen dieses Vertrags gewährt werden. Beim Hersteller handelt es sich um
Altova GmbH, Rudolfsplatz, 13a/9, A-1010 Wien, Österreich/EU. Die Software und/oder
Dokumentation darf ausschließlich unter Einhaltung aller anwendbaren Exportbestimmungen der
Vereinigten Staaten von Amerika sowie des Landes, in dem Sie die Software erhalten haben,
verwendet, exportiert oder wiedereingeführt werden. Insbesondere darf die Software und/oder
Dokumentation nicht (i) in ein Land exportiert oder wiedereingeführt werden, über das die
Vereinigten Staaten ein Embargo verhängt haben, oder einem Staatsangehörigen oder Bewohner
eines solchen Landes überlassen werden; oder (ii) einer Person überlassen werden, die auf der
Liste der Specially Designated Nationals des U.S. Treasury Department oder dem Table of Denial
Orders des U.S. Department of Commerce verzeichnet sind. Indem Sie die Software benutzen,
erklären Sie, dass Sie weder in einem dieser Länder ansässig sind noch seiner Kontrolle
unterliegen, noch ein Staatsangehöriger oder Bewohner eines dieser Länder sind, noch auf einer
der vorstehend erwähnten Listen genannt werden.
10. U.S.-REGIERUNGSBEHÖRDEN
Für Ämter, Institutionen oder Ministerien der Regierung der Vereinigten Staaten gelten für diesen
Vertrag ungeachtet der vorstehenden Bestimmungen amerikanisches Recht. Falls keine
amerikanischen Bundesgesetze anwendbar sind, so gelten die Gesetze des Commonwealth of
Massachusetts. Des Weiteren unterliegen alle Ansprüche, Forderungen, Beschwerden und
© 2016 Altova GmbH
Altova UModel 2017
486
Lizenzinformationen
Streitigkeiten ungeachtet anderslautender Bestimmungen in diesem Vertrag (einschließlich aber
nicht beschränkt auf Absatz 5 ((Garantie)) den folgenden amerikanischen Gesetzen bzw. anderen
US-Verordnungen: Contract Disputes Act (41 U.S.C. §§7101 et seq.), Tucker Act (28 U.S.C.
§1346(a) und §1491) oder dem Federal Tort Claims Act (28 U.S.C. §§1346(b), 2401-2402, 26712672, 2674-2680), FAR 1.601(a) und 43.102 (Contract Modifications); FAR 12.302(b). Der Klarheit
halber stellen wir fest: Wenn Sie ein amerikanisches bundestaatliches, staatliches oder
regionales Amt, eine Institution oder Behörde oder ein öffentliches und akkreditiertes
amerikanisches Bildungsinstitut sind, so können Schadenersatzansprüche an Sie nur im Rahmen
des geltenden amerikanischen Rechts (z.B. Anti-Deficiency Act) geltend gemacht werden und nur
in dem Ausmaß, in dem Sie die Autorisierungsbefugnis dazu haben.
11. SOFTWARE DRITTER
Die dieser Lizenz unterliegende Software kann Software Dritter enthalten, für die ergänzende
Vermerke und/oder Nutzungsbedingungen gelten. Diese Vermerke und ergänzenden
Nutzungsbedingungen für die Software Dritter können über unsere Website unter http://
www.altova.com/legal_3rdparty.html eingesehen werden und sind durch Bezugnahme Teil dieses
Lizenzvertrags. Indem Sie Ihre Zustimmung zu den Bedingungen dieses Vertrags erteilen,
stimmen Sie auch automatisch allen ergänzenden Bestimmungen, die möglicherweise darin
enthalten sind, zu.
12. ZUSTÄNDIGKEIT, ANWENDBARES RECHT UND GERICHTSBARKEIT
Wenn Sie sich in der Europäischen Union befinden und die Software in der Europäischen Union
und nicht in den Vereinigten Staaten verwenden, unterliegt dieser Vertrag dem Recht der Republik
Österreich (unter Ausschluss von dessen Verweisungsnormen und der UN-Kaufrechtskonvention).
Sie erklären sich ausdrücklich damit einverstanden, dass alle Streitigkeiten oder Konflikte mit
Altova, die in Zusammenhang mit Ihrer Verwendung der Software stehen, in die alleinige
Zuständigkeit des Handelsgerichts Wien fallen. Sie erklären sich weiters ausdrücklich damit
einverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikte der persönlichen
Zuständigkeit des Handelsgerichts Wien unterstellt sind.
Wenn Sie sich in den Vereinigten Staaten befinden und die Software in den Vereinigten Staaten
verwenden, unterliegt dieser Vertrag dem Recht des Commonwealth of Massachusetts, USA
(unter Ausschluss von dessen Verweisungsnormen und der UN-Kaufrechtskonvention). Sie
erklären sich ausdrücklich damit einverstanden, dass alle Streitigkeiten oder Konflikte mit Altova,
die in Zusammenhang mit Ihrer Verwendung der Software stehen, in die alleinige Zuständigkeit der
einzel- und bundesstaatlichen Gerichte im Bundesstaat Massachusetts fallen. Sie erklären sich
weiters ausdrücklich damit einverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikte
der persönlichen Zuständigkeit der einzel- und bundesstaatlichen Gerichte im Bundesstaat
Massachusetts unterstellt sind.
Wenn Sie sich nicht in der Europäischen Union oder den Vereinigten Staaten befinden und die
Software nicht in den Vereinigten Staaten verwenden, unterliegt dieser Vertrag dem Recht der
Republik Österreich (unter Ausschluss von dessen Verweisungsnormen und der UNKaufrechtskonvention). Sie erklären sich ausdrücklich damit einverstanden, dass alle
Streitigkeiten oder Konflikte mit Altova, die in Zusammenhang mit Ihrer Verwendung der Software
stehen, in die alleinige Zuständigkeit des Handelsgerichts Wien fallen. Sie erklären sich weiters
ausdrücklich damit einverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikte der
persönlichen Zuständigkeit des Handelsgerichts Wien unterstellt sind. Die Anwendung von
Verweisungsnormen einer Rechtsordnung sowie des UN-Abkommens zum internationalen
Warenkauf (CISG) auf diesen Vertrag wird ausdrücklich ausgeschlossen.
Altova UModel 2017
© 2016 Altova GmbH
Lizenzinformationen
13.
487
ÜBERSETZUNGEN
Von Altova zur Verfügung gestellte Übersetzungen der englischsprachigen Version dienen
ausschließlich Ihrer Annehmlichkeit. Die englischsprachige Version des Vertrags ist die offiziell
gültige. In Fällen, in denen die Übersetzung nicht mit der englischsprachigen Version
übereinstimmt, hat die englischsprachige Version Vorrang.
14.
ALLGEMEINE BESTIMMUNGEN
Dieser Vertrag enthält die gesamte Vereinbarung zwischen den Parteien in Bezug auf den
Vertragsgegenstand und tritt an die Stelle aller diesbezüglichen früheren mündlichen oder
schriftlichen Vereinbarungen zwischen den Parteien. Benachrichtigungen oder sonstige
Mitteilungen im Rahmen dieses Vertrags müssen schriftlich erfolgen und gelten als
ordnungsgemäß übermittelt, wenn sie per Einschreiben mit Rückschein oder per Kurierdienst mit
Zustellung am nächsten Tag an die auf der Website von Altova angegebene Adresse (wenn Altova
der Empfänger ist) bzw. an die in den Aufzeichnungen von Altova für Sie eingetragene Adresse
(wenn Sie der Empfänger sind) oder aber an eine andere, von den Vertragspartnern festgelegte
und auf die vorstehend beschriebene Weise bekannt gegebene Adresse geschickt werden. Dieser
Vertrag ist für die Vertragspartner verbindlich und geht auf ihre Erben, persönlichen und
rechtlichen Vertreter, verbundenen Unternehmen, Rechtsnachfolger und zulässigen
Abtretungsempfänger über. Die Nichtdurchsetzung oder Nichtausübung von Rechten oder
Rechtsmitteln unter diesem Vertrag durch die Vertragspartner stellt keinen Verzicht auf ein
solches Recht oder Rechtsmittel dar und beeinträchtigt in keiner Weise das Recht des
betreffenden Vertragspartners, ein solches Recht oder Rechtsmittel sowie alle anderen Rechte
oder Rechtsmittel aus diesem Vertrag später durchzusetzen bzw. auszuüben. Eine Änderung
dieses Vertrages ist nur in Form einer schriftlich niedergelegten Vereinbarung möglich, die von
beiden Vertragspartnern unterzeichnet wird. Wenn eine Zuwiderhandlung gegen die
Bestimmungen dieses Vertrags durch einen der Vertragspartner erfolgt ist oder droht, so kann der
jeweils andere Vertragspartner alle ihm zustehenden Rechte und Rechtsmittel geltend machen.
Jeder Vertragspartner ist ordnungsgemäß befugt und ermächtigt, in diesen Vertrag einzutreten
und die daraus erwachsenden Verpflichtungen zu erfüllen. Sollte eine Bestimmung dieses
Vertrags für unwirksam, rechtswidrig oder undurchführbar erklärt werden, so wird dadurch die
Wirksamkeit der übrigen Bestimmungen nicht berührt, und dieser Vertrag bleibt im
größtmöglichen rechtlich zulässigen Umfang wirksam und gültig. Die Vertragspartner haben die
vorstehenden Vertragsbedingungen zur Kenntnis genommen und erklären sich ausdrücklich damit
einverstanden.
Letzte Aktualisierung: 3.9.2015
© 2016 Altova GmbH
Altova UModel 2017
Index
Index
.
.NET Framework,
UModel Projekt inkludieren, 151
1
1.4,
Java, 59
5
5.0,
Java, 59
A
Abgeleitete,
Klasse, 32
Klassen einfügen, 98
Abhängigkeit,
Beziehungen anzeigen, 89, 177
inkludieren, 16
Verwendung, 43
Absolute,
und relative Links, 184
Abstrakte,
Klasse, 25
Akteur,
benutzerdefiniert, 16
Aktiviere Versionskontrolle, 363
Aktivierungsfeld,
Ausführungsspezifikation, 251
Aktivität, 212
Diagramm zu Transition hinzufügen, 212
Diagrammelemente, 201
Operation hinzufügen, 212
© 2016 Altova GmbH
489
Verzweigung / Merge erstellen, 199
zum Zustand hinzufügen, 212
Aktivitätsdiagramm, 196
Elemente einfügen, 197
Symbole, 393
Aktualisieren,
Projektdatei, 137
Aktuellste Version holen, 364
Alle,
erweitern/reduzieren, 285
Anbieter wechseln,
Versionskontrolle, 383
Anleitung,
definierte Symbole, 126
Anmerkung,
Hyperlink von, 100
Annotation,
Dokumentation, 86
XML-Schema, 328
Anordnen,
Elemente, 93
Anpassen, 430, 434
Befehle der Symbolleiste/des Menüs, 430
Kontextmenü, 434
Menü, 434
Ansicht, 427
zu mehreren Instanzen eines Elements, 285
Antwort,
Nachricht automatisch generieren, 257
Anwendungsfall,
hinzufügen, 16
Anzeigen, 83
alle Beziehungen - Hierarchie (Register), 83
Eigenschaft als Assoziation, 89
Eigenschaft als Assziation, 169
Eigenschaftswerte, 328
grafischen Ansicht, 83
Modellbeziehungen, 89, 177
oder am Raster ausrichten, 89
Regionsnamen ausblenden, 219
Textlabels, 89, 177
Applikation,
externe - Argumente, 431
Arbeit im Team,
Unterstützung - Unterprojekte, 346
Arbeitsablauf,
Projekt, 118
Arbeitsverzeichnis,
490
Arbeitsverzeichnis,
Argumente,
externe Tools, 431
Artefakt,
Manifestation, 48
zu Node hinzufügen, 48
Assoziation,
aggregrieren/zusammensetzen, 25
automatische Anzeige, 174
beim Code Engineering anzeigen, 59
Beziehungen anzeigen, 89, 177
Eigenschaft als Ass. anzeigen, 89
Klasse memberEnd, 174
mit Drag-and-Drop erstellen, 179
Objektverknüpfungen, 37
Qualifier, 174
Rolle, 174
Tpy definieren, 174
typisierte Eigenschaft anzeigen, 169
Use Case, 16
Zeilendicke, 89
zwischen Klassen, 25
Attribut,
Autokomplettierungsfenster, 437
Eigenschaftswerte ein-/ausblenden, 314
ein-/ausblenden, 285
in Modelll-Strukur auswählen, 78
Stereotyp, 314
Attribut auswählen,
in Modell-Struktur, 78
Attribute,
coloring, 291
Auflisten,
nicht verwendete Elemente, 69
Aufruf,
Nachricht, 257
Aufrufoperation,
einfügen, 197
Aufrufverhalten,
einfügen, 197
Ausblenden,
Eigenschaftswerte - Attribute, 314
einblenden - Slot, 285
Textlabels, 89, 177
Auschecken, 367
Auschecken rückgängig, 370
Ausführungsspezifikation,
Index
Lebenslinie, 251
Ausgabe,
XMI-Datei, 342
Ausgliedern,
aus Versionskontrolle, 374
Auslösendes Ereignis,
Zeitverlaufsdiagramm, 280
Ausnahme,
Ausnahmeereignis hinzufügen, 285
Ausnahmeereignis,
hinzufügen, 285
Java-Operation, 126
Ausrichten,
am Raster - Raster anzeigen, 89
beim Ziehen an Hilfslinien ausrichten, 437
Elemente, 93
Elemente beim Ziehen, 16
Ausrichtungshilfslinien, 16
Außer Kraft setzen,
SPL-Standardvorlagen, 137
Austrittspunkt,
zu Unterautomat hinzufügen, 219
Autokomplettierung, 93
Einzelmodus / Mehrfachmodus, 93
Fenster - Typen, 93
Fenster zum Bearbeiten von Klassen, 437
Funktion, 25
Autokomplettierung auf Wunsch,
Strg+Leertaste, 93
Automatisch,
Assoziationen anzeigen, 174
Automatisch generieren,
Antwortnachricht, 257
Automatischer,
Hyperlink, 100
B
Ball and socket,
Interface notation, 285
Bank,
Beispieldateien, 106
Basis,
Klasse, 32
Basisklasse,
abgeleitete einfügen, 98
© 2016 Altova GmbH
Index
Basisklasse,
überschreiben, 285
Batch, 114
Batchverarbeitung, 114
new / load / save, 114
Verarbeitung, 110
vollständiger Batch-Modus, 114
Bearbeiten, 416
Bearbeitungen rückgängig machen, 370
Befehl, 114, 434
aus Menü löschen, 434
Kontextmenü, 434
Menü zurücksetzen, 434
Zeile - new / load / save, 114
Zeilenverarbeitung, 114
Befehle,
zur Symbolleiste/zum Menü hinzufügen, 430
Befehlszeile,
Verarbeitung, 110
Beispiele,
Ordner Tutorial, 10
Benutzer,
examples Ordner für mehrere Benutzer, 10
Benutzerdefinierte,
SPL-Vorlagen, 137
Stereotypstile, 320
Benutzerdefinierter,
Akteur, 16
Benutzerdefiniertes,
Stereotypsymbol, 321
Benutzeroberfläche, 68
Bereich,
einzelne/mehrere erweitern, 285
Bezeichnung,
IDs und UUIDs, 342
Beziehung,
alle anzeigen - Hierarchie (Register), 83
Modellbeziehungen anzeigen, 89, 177
Beziehungen,
Element, 174
Verwendung von Ziehpunkten, 179
Binärdateien, 131
C# und Java importieren, 131
Unterstützung von "obfuscated" Binärdateien, 131
Bitmap,
Elemente speichern, 416
Borland,
© 2016 Altova GmbH
491
bsdj-Projektdatei, 419
Breite,
Linienbreite, 89
bsdj,
Borland-Projekt, 419
C
C#,
Binärdatei importieren, 131
Code, 450
Code in Modell - Entsprechungen, 147
Importeinstellungen, 126
C++,
Code, 450
Call-Nachricht,
gehe zu Operation, 257
Cascading,
Styles, 80
Class,
syntax coloring, 291
Classifier,
einschränken, 165
neu, 140
umbenennen, 140
Code, 52, 142
Code zu Sequenzdiagramm hinzufügen, 271
generieren - Mindestvoraussetzungen, 144
Java-Code und Klassendateinamen, 142
mehrere Sequenzdiagramm anhand von Code generieren, 266
Refactoring, 142
Round Trip Engineering, 52
Sequenzdiagramm generieren, 263
SPL, 451
Standard, 437
Synchronisierung, 137
von Sequenzdiagramm generieren, 268
Voraussetzungen, 52
Zielverzeichnis, 52
Code - C#,
in UModel Elemente, 147
Code - VB.NET,
to UModel elements, 149
Code - XML-Schema,
auf UModel Elemente, 148
Code Engineering, 52, 59
492
Code Engineering, 52, 59
Importverzeichnis, 59
Komponentenrealisierungen generieren, 140
Mini-Projekt, 121
Projektdatei in neuen Ordner verschieben, 118
Code Generator, 450
Codegenerierung,
Namespace als Verzeichnis verwenden, 52
Color,
syntax coloring - enable/disable, 291
Combined Fragment, 253
Constraint, 69
in Diagramm hinzufügen, 69
mehreren Elementen zuweisen, 69
Content Model,
des XML-Schemas, 334
Copyright-Informationen, 468
CR/LF,
für ump-Datei beim Speichern, 118
csproj - csdproj,
MS Visual Studio .Net, 419
D
Datei, 411
new / load / save - Batch, 114
Projektdateien zusammenführen, 153
Tutorial-Beispiel, 10
ump, 118
von URL öffnen, 411
Datei abrufen,
Datei holen,
Dateien,
Datentype,
in Schema definieren, 334
Datentypen,
hinzufügen - Autokomplettierung, 93
Deaktiviere Versionskontrolle, 363
Definierte,
Symbole - Code importieren, 126
Deployment,
Diagramm, 48
Index
Symbole, 398
Deployment-Diagramm, 304
Diagram,
- Use Case-Diagramm, 239
Diagramm, 266, 285, 306
- Aktivitätsdiagramm, 196
- Interaktionsübersichtsdiagramm, 244
- Klassendiagramm, 285
- Profil, 312
Aktivität zu Transition hinzufügen, 212
alle bis auf das aktive schließen, 89
als png speichern, 411
Code von Sequenzdiagramm generieren, 268
Code zu Sequenzdiagramm hinzufügen, 271
Deployment-Diagramm, 304
Diagrammüberschrift anzeigen, 93
Eigenschaften, 89
Elemente als Bitmap speichern, 416
Elemente aus inkludierten Dateien igrnoieren, 437
Elemente durch Constraint einschränken, 69
Größe anpassen, 89
Hyperlink, 100
Kommunikationsdiagramm, 240
Komponentendiagramm, 303
Kompositionsstrukturdiagramm, 300
Linienbreite, 89
mehrere Klasseninstanzen, 285
mehrere Sequenzdiagramm anhand eines Diagramms
generieren, 266
nur in Diagramm einfügen, 95
Objektdiagramm, 305
offene Diagramme mit Projekt speichern, 437
öffnen, 74
Paket und Diagramm freigeben, 161
Paketabhängigkeiten erstellen, 306
Paktediagramm, 306
Quellcodekommentare anzeigen, 89
Sequenzdiagramm, 249
Sequenzdiagramm anhand von Getter / Setter generieren, 266
Stile, 80
Symbole, 392
XML-Schema, 327
XML-Schema - Import, 328
Zusätzliches - XML-Schema, 326
Zustandsdiagramm, 211
Diagramme, 194
© 2016 Altova GmbH
Index
Diagramme, 194
Strukturdiagramme, 284
Verhaltensdiagramme, 195
Diagrammfenster, 89
Diagramm-Struktur, 74
Dokument,
Hyperlink zu, 100
Dokumentation, 184
Annotation, 86
relative Links, 184
UML-Projekt generieren, 184
Dokumentation (Register), 86
Download Versionskontroll-Projekt, 360
Drag and Drop,
rechte Maustaste, 98
Drag-and-Drop,
Assoziation mit Ziehpunkten erstellen, 179
Druckaufbereitung,
XMI-Ausgabe, 342
Drucken,
Druckvorschau, 411
Duchsuchen von Registern, 68
Durch Constraint einschränken,
Element, 69
E
Eigenschaft,
als Assoziation anzeigen, 89, 177
als Lebenslinie typisiert, 251
typisierte - anzeigen, 169
wiederverwenden, 32
Eigenschaften, 78
hinzufügen, 25
Eigenschaftswert,
Standardwert, 318
Eigenschaftswerte,
anzeigen, 328
Attribute ein-/ausblenden, 314
Definitionen, 312
Ein-/ausblenden,
Attribute, Operationen, 285
Ein-/Ausschalten,
Kompaktmodus, 328
Einblenden,
© 2016 Altova GmbH
493
ausblenden - Eigenschaftswerte / Attribute, 314
ausblenden - Slot, 285
Einchecken, 369
Einfügen, 197
Aktion (Aufrufoperation), 197
Aktion (Aufrufverhalten), 197
einfachen Zustand, 212
Element in Diagramm, 95
Elemente, 98
Interaktionsübersichtselemente, 245
Kompositionsstrukturelemente, 300
mit..., 98
nur in Diagramm, 95
Paketdiagrammelemente, 307
Zeitverlaufsdiagrammelemente, 276
Einführung, 6
Einschränken,
Classifier, 165
Elemente durch Constraint einschränken, 69
Einschränkung,
Syntaxüberprüfung, 419
Einstelllungen,
Einstellungen,
Eintrittspunkt,
zu Unterautomat hinzufügen, 219
Einzelmodus,
Element, 69
Assoziationen beim Importieren, 59
ausgewählte als Bitmap speichern, 416
ausrichten, 93
ausschneiden, kopieren, einfügen, 95
Beziehungen, 174
Constraint zuweisen, 69
Dokumentation generieren, 184
durch Constraint einschränken, 69
Eigenschaften, 78
einfügen, 98
Hierarchie anzeigen, 83
Hyperlink zu Element erstellen, 100
Stile, 80
zu Favoriten hinzufügen, 76
Elemente,
aus Include-Dateien ignorieren, 437
Zustandsdiagramm einfügen, 212
Endbenutzer-Lizenzvereinbarung, 468, 473
494
Entfernen,
aus Favoriten, 76
Enumeration,
Standardwert, 318
und Stereotype, 318
Erstellen,
getter / setter Methoden, 285
XML-Schema, 337
Erweitern,
alle Klassenbereiche, 285
Pakete reduzieren, 69
Erweiterung,
XMI, 342
Evaluierungszeitraum,
bei Altova Software-Produkten, 472
für Altova-Software-Produkte, 469
von Altova Software-Produkten, 468
Export,
als XMI, 342
Extras, 428
Optionen, 437
Zum Menü 'Extras' hinzufügen, 431
F
Farbe,
transparenter Hintergrund, 321
Favoriten, 76
Fehlende Elemente,
auflisten, 69
Fehler,
Meldungen, 88
Fenster, 443
Standardeinstellungen wiederherstellen, 428
Fensterbereich "Meldungen", 88
Filtertypen,
Format,
benutzerdefiniertes Stereotypformat, 320
Forward,
Engineering, 144
Freigeben,
aus Versionskontrolle, 375
Paket und Diagramm, 161
Index
G
Gate,
Gehe zu,
Lebenslinie, 251
Generalisieren,
spezialisieren, 32
Generics,
Unterstützung für Java und C#, 165
Generieren,
Antwortnachricht automatisch generieren, 257
Code von Schema, 450
Komponentenrealisierungen automatisch generieren, 140
mehrere Sequenzdiagramm anhand von Code generieren, 266
Sequenzdiagramm anhand von Code, 263
Sequenzdiagramm von Kommunikationsdiagramm, 240
UML-Projektdokumentation, 184
XML-Schema, 337
Geschwindigkeit,
Verbesserung, 171
Get,
Getter / Setter,
Grafische Ansicht,
einzige Gruppe von Beziehungen, 83
Größe,
Diagrammfenster, 89
H
Hierarchie,
alle Beziehungen anzeigen, 83
Hierarchiediagramm,
In Dokumentation angezeigte Ebenen, 184
Hilfe, 444
Hilfslinie,
beim Ziehen mit der Maus, 437
Hintergrund,
transparente Farbe, 321
Hinzufügen, 16, 371
Diagramm zu Paket, 16
© 2016 Altova GmbH
Index
Hinzufügen, 16, 371
Einfügen - Löschen aus der Modell-Struktur, 69
Modell-Link, 100
neues Projekt, 118
Paket zu Projekt, 16
Projekt in Versionskontrolle, 371
verschieben - löschen - Diagramm, 89
zu Favoriten, 76
Höhe angleichen,
Höhe - Breite - Größe, 93
Hyperlink, 100
automatischer, 100
I
ID,
IDs und UUIDs, 342
Ignorieren,
Elemente in Liste, 437
Operationsnamen, 263
Verzeichnisse, 437
Import, 59
Assoziationselemente, 59
C#-Projekt, 126
Quellprojekt, 59
Verzeichnis, 59
XMI-Datei, 342
XML-Schema, 328
Importieren, 126
Binärdateien, 131
Projekt, 126
Quellcode, 126
relativ zur UMP-Datei, 126
von UModel generierte XMI-Datei, 342
Inkludieren, 161
.NET Framework, 151
Abhängigkeit, 16
Paket und Diagramm freigeben, 161
Status - ändern, 161
UModel Projekt, 151
Unterprojekt wieder in Hauptprojekt inkludieren, 347
Installation,
Ordner examples, 10
Installer,
mehrere Benutzer, 10
© 2016 Altova GmbH
495
Instanz, 37
Diagramm, 37
mehrere Klassen, Anzeige, 285
Objekt, 37
Integrieren,
Unterprojekte in Hauptprojekt inkludieren, 347
Intelligentes,
Autokomplettieren, 25
Interaction Use, 256
Interaktinosoperand, 253
Interaktionsoperand,
mehrzeiliger, 253
Interaktionsoperator,
definieren, 253
Interaktionsübersicht,
Interaktionsübersichtsdiagramm, 244
Symbole, 399
Interface,
ball and socket, 285
J
Java,
Ausnahmeereignis, 126
Binärdatei importieren, 131
Code, 450
Code und Klassendateinamen, 142
Namespace Root, 144
unterstützte Versionen, 59
JavaDocs, 86
K
Katalog,
Datei - XMLSpy Katalogdatei, 437
Klasse, 121, 285
abgeleitete, 32
abgeleitete Klassen einfügen, 98
abstrakte und konkrete, 25
Assoziationen, 25
Autokomplettierungsfenster aktivieren, 437
ball and socket interface, 285
Basis, 32
496
Klasse, 121, 285
Basisklasse überschreiben, 285
Eigenschaften hinzufügen, 25
erweitern, Bereiche reduzieren, 285
in Komponentendiagramm, 43
in Namespace erstellen, 121
in Namespace generieren, 121
mehrere Instanzen in einem Diagramm, 285
Namensänderungen - Synchronisierung, 142
Operation - überschreiben, 285
Operationen hinzufügen, 25
Symbole, 394
Klassendiagramm, 285
neues hinzufügen, 25
Klassennamen ändern,
Auswirkung auf Codedateinamen, 142
Knoten,
Stile, 80
Kollaboration,
Kommentare,
Dokumentation, 86
Quellcodekommentare im Diagramm anzeigen, 89
Symbole, 395
von Sequenzdiagramm generieren, 240
Kompakt,
Modus - ein-/ausschalten, 328
Kompatibilität,
Projekte aktualisieren, 137
Komponente, 43
Diagramm, 43
Klasse einfügen, 43
Realisierung, 43
Symbole, 397
Komponentendiagramm, 303
Komponentenrealisierung,
automatische Generierung, 140
Komposition,
Assoziation - erstellen, 25
Kompositionsstruktur,
Symbole, 396
Konkrete,
Klasse, 25
Kontextmenü,
Index
Befehle, 434
Kopieren,
einfügen in Diagramm, Modell-Struktur, 95
L
Label,
Textlaben ein-/ausblenden, 89, 177
Layout, 426
Lebenslinie,
allgemeiner Wert, 276
Attribute, 251
Eigenschaft vom Typ Lebenslinie, 251
Gehe zu, 251
Linie,
orthogonal, 43
Linien,
formatieren, 37
Hilfslinien, 437
Stärke/Dicke in Diagrammen, 89
Link, 100
Hyperlink erstellen, 100
Model-Strukturelement, 100
Links,
relativ zur Dokumentation, 184
Lizenz, 473
Informationen, 468
Lizenzüberwachung,
bei Altova-Produkten, 470
Lokale Dateien,
absolute oder relative Links, 184
Lokales Projekt, 360
Löschen,
aus Favoriten, 76
Befehl aus der Symbolleiste löschen, 430
Befehl aus Kontextmenü, 434
Klassenbeziehung, 174
Symbol aus der Symbolleiste, 430
Symbolleiste, 430
Tastaturkürzel, 434
M
Mail,
© 2016 Altova GmbH
Index
Mail,
Projekt senden, 411
Manifest,
Artekfakt, 48
Mappen,
C# in/von Modellelementen, 147
Mapping,
VB.NET to/from model elements, 149
XML-Schema von/auf Modellelemente, 148
Maus,
kopieren, einfügen, 95
Mehrere Benutzer,
Ordner examples, 10
Mehrere Elemente,
Stilanzeige, 80
Mehrfachmodus,
Mehrzeilig,
Use Case, 16
Mehrzeiliger,
Akteurtext, 16
Interaktionsoperand, 253
Meine Dokumente,
Beispieldateien, 10
Member End,
Stereotyp, 314
MemberEnd,
Assoziation, 174
Menü, 434
Anpassen, 434
Ansicht, 427
bearbeiten, 416
Befehl hinzufügen/löschen, 430
Befehle daraus löschen, 434
Datei, 411
Extras, 428
Fenster, 443
Hilfe, 444
Layout, 426
Menü hinzufügen, 431
Projekt, 419
Standardmenü/XMLSPY, 434
Merge,
in Aktivität erstellen, 199
Mergen,
Code aus dem Modell, 52
Metadaten,
XMI-Ausgabe, 342
© 2016 Altova GmbH
497
Methode, 266
Ausnahmeereignis hinzufügen, 285
mehrere Sequenzdiagramm generieren, 266
Methoden,
getter / setter, 285
Mindestvoraussetzungen,
Bedingungen für die Codegenerierung, 144
Miniprojekt,
Code Engineering, 121
Modell,
Klassennamen ändern - Auswirkung in Java, 142
Link, hinzufügen, 100
Modell von Code,
Modellieren,
Performance verbessern, 171
Modell-Struktur, 69
Attribut auswählen, 78
Fensterbereich, 69
Hyperlink zu Element erstellen, 100
Pakete öffnen, 69
MS Visual Studio .Net,
csproj - csdproj-Projektdatei, 419
N
Nachricht, 257
Aufruf, 257
einfügen, 257
gehe zu Operation, 257
nummerieren, 257
Objekt erstellen, 257
Pfeile, 257
verschieben, 257
Nachrichtenpfeile verschieben, 257
Name,
Regionsnamen - ein- /ausblenden, 219
Namespace,
erstellen - Code Engineering, 121
Java Namespace Root, 144
Verwendung für Codegenerierung, 52
Native Oberfläche ausführen, 382
Navigieren,
498
Navigieren,
Hyperlink, 100
Neu,
Classifier, 140
Neue Zeile,
in Lebenslinie, 240
Interaktionsoperand, 253
Nicht verwendete Elemente,
auflisten, 69
Node,
Artefakt hinzufügen, 48
hinzufügen, 48
Nummerieren,
Nachrichten, 257
O
Objekt, 37
Diagramm, 37
Nachricht erstellen, 257
Symbole, 400
Verknüpfungen - Assoziationen, 37
Objektdiagramm, 305
Öffnen,
Diagramm, 74
Pakete in der Baumstrukturansicht, 69
Projekt-Versionskontrolle, 360
URL, 411
Operand,
Interaktion, 253
Operation, 285
Ausnahmeereignis, 126
automatisch zu Aktivität hinzufügen, 212
beim Generieren von Sequenzdiagrammen ignorieren, 263
coloring, 291
gehe zu von Call-Nachricht, 257
überschreiben, 285
Vorlage, 169
wiederverwenden, 32
Operation automatisch hinzufügen, 212
Operationen,
hinzufügen, 25
Operator,
Interaktion, 253
Index
Optionen,
Extras, 437
Projekt, 170
Ordner,
in Versionskontrolle abrufen, 366
Ordner examples, 10
Ordner abrufen,
Orthogonale,
Linie, 43
Orthogonaler,
Zustand, 219
OwnedEnd,
Assoziation, 174
Ownership,
Punkt, 179
P
Paket,
als Namespace-Paket erstellen, 121
erweitern/reduzieren, 69
freigeben, 161
Profil, 314
Paketdiagramm, 306
Abhängigkeiten erstellen, 306
Symbole, 401
Paketmerge, 307
Pakteimport, 307
Parameter,
Batch, 110
Vorlage, 169
Performance,
Verbesserung, 171
Pfad,
Import relativ zur UMP-Datei, 126
Namespace in Code verwenden, 52
Ordner examples, 10
Projekt verschieben, 118
Projektordner ändern, 118
SPL-Vorlagenpfad, 453
PNG,
Diagramm speichern, 411
Pretty Print,
© 2016 Altova GmbH
Index
Pretty Print,
Projekt mit Pretty Print speichern, 118
Profil, 312
- Diagramm, 312
Diagramm, 312
Stereotype, 314
Zuweisung, 312
Projekt, 419
2-Weg-Zusammenführung, 154
3-Weg-Zusammenführung, 155, 158
Arbeitsablauf, 118
Datei - aktualisieren, 137
Dokumentation generieren, 184
entfernen aus Versionskontrolle, 374
erstellen, 118
Hinzufügen in Versionskontrolle, 371
importieren, 126
letzten beim Starten öffnen, 437
Namespace-Paket erstellen, 121
offene Diagramme speichern, 437
Optionen, 170
Paket einfügen, 118
per E-Mail senden, 411
speichern - Pretty Print, 118
Standardcode, 437
Stile, 80
UModel Projekt inkludieren, 151
Unterprojekte erstellen, 347
verschieben, 118
zusammenführen, 153
Projekt öffnen,
Projektdateien,
Borland - MS Visual Studio .Net, 419
Projektzusammenführung,
2-Weg, 154
3-Weg, 155, 158
Property,
coloring, 291
Provider,
auswählen, 360
Punkt,
Ownership, 179
© 2016 Altova GmbH
499
Q
Qualifier,
Assoziation, 174
Quellcode,
importieren, 126
Quelle,
Codekommentare - im Diagramm anzeigen, 89
R
Rahmen,
UML-Diagrammüberschrift anzeigen, 93
Raster,
Elemente an Hilfslinien ausrichten, 16
Hilfslinien, 437
Raster anzeigen, 89
Realisierung,
Komponente, 43
Komponentenrealisierungen generieren, 140
Rechtliches, 468
Rechts ziehen, 98
Reduzieren,
Klassenbereiche, 285
Refactoring,
Klassennamen - Synchronisierung, 142
Referenz, 410
referenzierte Klasse anzeigen, 89
Region,
zu zusammengesetztem Zustand hinzufügen, 219
Regionsname,
ein- / ausblenden, 219
Relativ,
Dateien importieren/speichern, 126
Relative,
Links, 184
Rolle,
Assoziation, 174
Root,
Java Namespace, 144
Katalog - XMLSpy, 437
Paket/Klasse synchronisieren, 137
Round Trip, 52
500
Round Trip, 52
Code - Modell -Code, 59
Engineering, 52
Modell - Code - Modell, 52
S
SC,
syntax coloring, 291
Schaltflächen,
Sichtbarkeitsschaltflächen, 285
Schema,
Code Generator, 450
Datentype - definieren, 334
XML-Schema, 327
XML-Schema - Import, 328
XML-Schema erstellen, 337
Schließen,
alle Diagramme bis auf das aktive, 89
Schnittstelle,
implementieren, 285
Seite,
Umbruch verhindern, 411
Senden per E-Mail,
Projekt, 411
Sequenz,
Symbole, 404
Code generieren, 268
Code hinzufügen, 271
Combined Fragment, 253
Gate, 256
Interaction Use, 256
Lebenslinie, 251
Nachrichten, 257
von Kommunikationsdiagarmm generieren, 240
zu ignorierende Operationsnamen, 263
Zustandsinvariante, 257
Set,
Setter / Getter,
Shortcut, 434
Show,
tagged values, 331
Index
Sichtbarkeit,
Schaltflächen - auswählen, 285
Signatur,
Vorlage, 165, 167
Slot,
Software-Produktlizenz, 473
Sortieren,
Diagramm, 74
Elemente in der Modell-Struktur, 69
Speichern,
Diagramm als Bild speichern, 411
Elemente als Bitmap, 416
Unterprojektdateien, 347
Spezialisieren,
generalisieren, 32
SPL, 451
benutzerdefinierte, 137
Codeblöcke, 452
foreach, 462
SPL-Vorlagen,
Vorlagenpfad, 453
Standard,
Pfad - Ordner examples, 10
Projektcode, 437
SPL-Vorlagen, 137
Standardmenü,
Menü, 434
Standardwert,
Eigenschaftswert, 314
Start,
UModel, 12
Starten,
mit letzten Projekt, 437
Status aktualisieren,
Stereotyp,
Attribute - definieren, 314
benutzerdefinierte Stile, 320
benutzerdefiniertes Symbol, 321
Member End, 314
Profile, 314
Standardeigenschaftswert, 318
und Enumeration, 318
zuweisen, 314
Stereotype,
Definition, 312
Stil,
© 2016 Altova GmbH
Index
Stil,
benutzerdefinierte Stereotypstile, 320
Stile,
cascading Styles, Vorrang, 80
mehrere Auswahlen, 80
Stile (Register), 80
Strg+Leertaste,
Autokomplettierung auf Wunsch, 93
Strukturdiagramme,
Diagramme, 284
Suchen, 69
Modellierungselemente, 69, 416
nicht verwendete Elemente, 69
Register durchsuchen, 68
Symbol, 398
Aktivitätsdiagramm, 393
benutzerdefiniertes Stereotypsymbol, 321
Deployment, 398
groß anzeigen, 435
Klasse, 394
Komponente, 397
Objekt, 400
Sequenz, 404
Verteilung, 398
zur Symbolleiste/zum Menü hinzufügen, 430
Symbole,
definierte - Code importieren, 126
Interaktionsübersichtsdiagramm, 399
Paketdiagramm, 401
Use Case, 407
XML-Schemadiagramm, 408
Zustandsdiagramm, 405
Symbolleiste,
aktivieren/deaktivieren, 430
Befehl hinzufügen, 430
große Symbole anzeigen, 435
neue erstellen, 430
Standardeinstellungen wiederherstellen, 428
Symbolleiste & Menübefehle zurücksetzen, 430
Synchronisieren,
Code aus dem Modell übernehmen, 52
mit neuem Ordner, 118
Modell von Code mergen, 59
Root/Paket/Klasse, 137
© 2016 Altova GmbH
501
Änderung von Klassennamen, 142
Einstellungen, 137
Klasse und Codedateinamen, 142
Syntax, 52
Batch-Datei, 110
Fehler - Warnungen, 52
Projektsyntax überprüfen, 419
überprüfen, 52
Überprüfung - Meldungen, 88
Syntax coloring, 291
T
Tagged values,
show, 331
Tastaturkürzel,
in Tooltipp anzeigen, 435
zuweisen/löschen, 434
Teamwork,
Unterstützung - Unterprojekte, 346
Teilweise Dokumentation,
generieren, 184
Textlabels,
ein-/ausblenden, 89, 177
Tick-Symbol,
Tooltipp, 435
anzeigen, 435
Tastaturkürzel anzeigen, 435
Transition, 212
Aktivitätsdiagramm hinzufügen, 212
Trigger definieren, 212
zwischen Zuständen definieren, 212
transparent,
Hintergrundfarbe, 321
Trigger,
Transitions-Trigger definieren, 212
Tutorial, 10
Beispieldateien, 10
Ordner examples, 10
Ziele, 10
Typ,
Eigenschaft - anzeigen, 169
Typen,
und Autokomplettierung, 93
Typisieren,
502
Typisieren,
Eigenschaft - als Lebenslinie, 251
U
Überführen,
Code in Modell, 419
Modell in Code, 419
Überprüfen,
Projektsyntax, 419
Überschreiben,
Code aus Modell, 419
Klassenoperationen, 285
Modell aus Code, 419
Überschrift,
UML-Diagrammüberschrift anzeigen, 93
Übersicht (Fensterbereich), 86
Umbenennen,
Classifier, 140
Umbruch,
Umbruch verhindern, 411
UML,
Diagramm - freigeben, 161
Diagramme, 194
Diagrammüberschrift - anzeigen, 93
Sichtbarkeitsschaltflächen, 285
Variablen, 453
Vorlagen, 165
UModel,
auf XML-Schema-Code, 148
generierte XMI-Datei importieren, 342
in C# Code, 147
starten, 12
to VB.NET code, 149
UModel Diagrammsymbole, 392
UModel Einführung, 6
UMP,
Dateierweiterung, 118
Projektverzeichnis ändern, 118
Unleserlich gemacht,
Unterstützung unleserlich gemachter Binärdateien, 131
Unterautomatenzustand,
neuen Eintrtts-/Austrittspunkt hinzufügen, 219
Unterklasse,
in Diagramm einfügen, 98
Unterprojekt, 347
Index
erstellen, 347
öffnen / bearbeiten, 347
und Versionskontrolle, 346
Unterprojektdateien speichern, 347
Unterprojekte,
Unterstützung für die Arbeit im Team, 346
Unterschiede anzeigen, 378
URL,
Datei über URL öffnen, 411
Use Case, 16
Assoziation, 16
Bereiche, 16
hinzufügen, 16
mehrzeilig, 16
Symbole, 407
Use Case diagram, 239
UUID,
Universal Unique Identifiers, 342
V
value,
tagged, show, 331
Variablen,
externe Tool-Argumente, 431
UML, 453
VB.NET,
code to model correspondence, 149
Verbessern,
Performance, 171
Verhaltensdiagramme, 195
Verlauf,
anzeigen, 376
Verlauf anzeigen, 376
Verschieben,
Projekt, 118
Versionsdateien vergleichen, 378
Versionskontrolle,
aktivieren /deaktivieren, 363
aktuellste Version holen, 364
auschecken, 367
Auschecken rückgängig, 370
ausgliedern, 374
Befehle, 359
Datei abrufen, 365
Eigenschaften, 380
© 2016 Altova GmbH
Index
Versionskontrolle,
Einchecken, 369
Hinzufügen in Versionskontrolle, 371
installieren eines Versionskontroll-Plug-in, 354
native Oberfläche ausführen, 382
Optionen / Einstellungen, 437
Projekt öffnen, 360
Status aktualisieren, 381
Unterprojekte - Arbeit im Team, 346
Unterschiede anzeigen, 378
Verlauf anzeigen, 376
Versionskontrollsystem wechseln, 383
Verteilung,
Symbole, 398
Vertrieb,
von Altova Produken, 472
von Altova Software-Produkten, 468
von Altova-Software-Produkten, 469
Verwendung,
Abhängigkeit, 43
Vorlage, 168
Verzeichnis, 52
beim Zusammenführen igrnoieren, 437
Code importieren, 126
für Codegenerierung, 52
importieren, 59
Namespace in Pfad verwenden, 52
Ordner examples, 10
Projektverzeichnis ändern, 118
Verzweigung,
in Aktivität erstellen, 199
Vollständiger Batch-Modus, 114
Voraussetzungen,
Forward Engineering, 144
Vorlage,
Signatur, 165, 167
Verwendung, 168
Vorlagen,
benutzerdefinierte SPL, 137
Operation/Parameter, 169
SPL-Vorlagen, 453
W
Waagrecht anordnen, 93
Warnung,
© 2016 Altova GmbH
503
Meldungen, 88
Syntaxküberprüfung, 52
Web,
Hyperlink, 100
Wert,
Eigenschaftsswert, 314
Werte,
Eigenschaftswerte, 312
Eigenschaftswerte anzeigen, 328
Wertverlaufslinie,
Wiederherstellen,
Symbolleisten und Fenster, 428
Wiederverwendung,
von Unterprojekten, 347
X
XMI, 342
Druckaufbereitung für die Ausgabe, 342
Erweiterungen, 342
XML-Schema, 334
Annotation, 328
Diagramm, 327
Entsprechung Code - Modell, 148
erstellen/generieren, 337
XML-Schema - Element einfügen,
Content Model, 334
XML-Schemadiagramm,
Symbole, 408
Z
Zeilenumbruch,
im Akteurtext, 16
Zeitbedingung,
Zeitdauerbedingung,
Zeitlinie,
Zustandsänderungen definieren, 276
Zeitverlaufsdiagramm, 275, 276
auslösendes Ereignis, 280
504
Index
Zeitverlaufsdiagramm, 275, 276
Lebenslinie, 276
Nachricht, 282
Symbole, 406
Tick-Symbol, 279
wechseln zwischen Typen, 276
Wertverlaufslinie, 276
Zeitbedingung, 281
Zeitdauerbedingung, 280
Zeitlinie, 276
Zentrieren,
Elemente, 93
Ziehpunkt,
Beziehung erstellen, 179
Zoomen,
Größe anpassen, 89
Zurücksetzen,
Menübefehle, 434
Symbolleiste & Menübefehle, 430
Tastaturkürzel, 434
Zusammenführen,
Projekte, 153
Verzeichnis ignorieren, 437
Zusammenführung,
2-Weg-Projektzusammenführung, 154
3-Weg-Projektzusammenführung, 155, 158
Zusammengesetzter Zustand,
Region hinzufügen, 219
Zustand, 212
Aktivität hinzufügen, 212
einfachen einfügen, 212
orthogonaler, 219
Transition definieren, 212
Unterautomatenzustand, 219
zusammengesetzter, 219
Zustandsänderungen,
auf einer Zeitlinie definieren, 276
Zustandsdiagramm,
Diagrammelemente, 231
Symbole, 405
zusammengesetzte Zustände - Regionen, 219
Zustände, Aktivitäten, Transitionen, 212
Zustandsdiragramm, 211
Zustandsinvariante, 257
Zuweisen,
Stereotyp, 314
Tastaturkürzel zu einem Befehl, 434
© 2016 Altova GmbH

Altova UModel 2016

Transcription

Similar documents

Technical Report as PDF - Institut für Informatik

Inhaltsverzeichnis

Faszination Mikrosystemtechnik

Altova XMLSpy 2011

endpunkt uml diagramm

DIE GANZE WELT DER DATEN IN IHRER HAND ATLAS.ti 7

Adobe® Dreamweaver® CS4 verwenden

MCN-Soft Software Bedienungsanleitung - ACS-Control

Basiskonzepte

www.jurijs-skripte.de.vu UML