benutzer- und referenzhandbuch - altova.com · uml (unified modeling language) ist eine...
TRANSCRIPT
Benutzer- und Referenzhandbuch
All rights reserved. No parts of this work may be reproduced in any form or by anymeans - graphic, electronic, or mechanical, including photocopying, recording, taping, orinformation storage and retrieval systems - without the written permission of thepublisher.
Products that are referred to in this document may be either trademarks and/orregistered trademarks of the respective owners. The publisher and the author make noclaim to these trademarks.
While every precaution has been taken in the preparation of this document, thepublisher and the author assume no responsibility for errors or omissions, or fordamages resulting from the use of information contained in this document or from theuse of programs and source code that may accompany it. In no event shall the publisherand the author be liable for any loss of profit or any other commercial damage caused oralleged to have been caused directly or indirectly by this document.
Published: 2017
© 2017 Altova GmbH
UML®, OMG™, Object Management Group™, and Unified Modeling Language™ areeither registered trademarks or trademarks of Object Management Group, Inc. in theUnited States and/or other countries.
Altova UModel 2017 Benutzer- undReferenzhandbuch
1Altova UModel 2017
Inhaltsverzeichnis
1 UModel 3
2 Einführung in UModel 6
3 UModel Tutorial 10
................................................................................................................. 123.1 Starten von UModel
................................................................................................................. 163.2 Use Cases
................................................................................................................. 253.3 Klassendiagramme
................................................................................................... 31Erstellen von abgeleiteten Klassen 3.3.1
................................................................................................................. 373.4 Objektdiagramme
................................................................................................................. 433.5 Komponentendiagramme
................................................................................................................. 483.6 Deployment-Diagramme
................................................................................................................. 523.7 Round-Trip Engineering (Modell - Code - Modell)
................................................................................................................. 593.8 Round-Trip Engineering (Code - Modell - Code)
4 UModel Benutzeroberfläche 68
................................................................................................................. 694.1 Modell-Struktur
................................................................................................................. 744.2 Diagramm-Struktur
................................................................................................................. 764.3 Favoriten
................................................................................................................. 784.4 Eigenschaften
................................................................................................................. 804.5 Stile
................................................................................................................. 834.6 Hierarchie
................................................................................................................. 864.7 Übersicht - Dokumentation
................................................................................................................. 874.8 Dokumentation
................................................................................................................. 884.9 Meldungen
................................................................................................................. 894.10 Diagrammfenster
................................................................................................... 93Diagrammeigenschaften 4.10.1
................................................................................................... 95Ausschneiden, Kopieren und Einfügen in UModel Diagramme 4.10.2
................................................................................................................. 984.11 Hinzufügen/Einfügen von Modellelementen
................................................................................................................. 1004.12 Verknüpfen von Modellierungselementen
Altova UModel 20172
................................................................................................................. 1064.13 Bank-Beispieldateien
5 UModel Befehlszeilenschnittstelle 110
................................................................................................................. 1145.1 Datei: New / Load / Save-Optionen
6 Projekte und Code Engineering 118
................................................................................................................. 1216.1 Mini-UModel Projekt - von Grund auf neu erstellen
................................................................................................................. 1266.2 Importieren von Quellcode in Projekte
................................................................................................................. 1316.3 Importieren von Java-, C#- und VB-Binärdateien
................................................................................................................. 1376.4 Synchronisieren von Modell und Quellcode
................................................................................................... 139Tipps zur Synchronisierung 6.4.1
................................................................................................... 141Refactoring und Synchronisierung von Code 6.4.2
................................................................................................................. 1436.5 Voraussetzungen für Forward Engineering
................................................................................................................. 1456.6 Generieren von Java-Code aus UModel-Elementen und umgekehrt
................................................................................................................. 1466.7 Generieren von C#-Code aus UModel Elementen und umgekehrt
................................................................................................................. 1476.8 XML Schema von/zu UModel Elementen
................................................................................................................. 1486.9 Konvertierung VB.NET-Code - UModel-Elemente
................................................................................................................. 1496.10 Inkludieren anderer UModel-Projekte
................................................................................................................. 1516.11 Zusammenführen von UModel-Projekten
................................................................................................... 1512-Weg-Projektzusammenführung 6.11.1
................................................................................................... 1523-Weg-Projektzusammenführung 6.11.2
................................................................................................... 154Beispiel: Manuelle 3-Weg-Projektzusammenführung 6.11.3
................................................................................................................. 1586.12 Freigeben von Paketen und Diagrammen
................................................................................................................. 1626.13 UML-Vorlagen
................................................................................................... 163Vorlagensignaturen 6.13.1
................................................................................................... 164Vorlagenverwendung 6.13.2
................................................................................................... 164Vorlagenverwendung in Operationen und Eigenschaften 6.13.3
................................................................................................................. 1666.14 Projekteinstellungen
................................................................................................................. 1676.15 Verbesserung der Performance
7 Erstellen von Modellbeziehungen 170
................................................................................................................. 1737.1 Anzeigen von Modellbeziehungen
................................................................................................................. 1757.2 Assoziationen, Realisierungen und Abhängigkeiten
8 Generieren von UML-Dokumentation 180
3Altova UModel 2017
................................................................................................................. 1868.1 Vordefiniertes SPS-Stylesheet
................................................................................................................. 1888.2 Benutzerdefinierte Stylesheets
9 UML-Diagramme 192
................................................................................................................. 1939.1 Verhaltensdiagramme
................................................................................................... 193Aktivitätsdiagramm 9.1.1
........................................................................................................... 194Einf ügen von Aktivitätsdiagrammelementen
........................................................................................................... 196Erstellen von Verzweigungen und Merges
........................................................................................................... 199Aktivitätsdiagramm-Elemente
................................................................................................... 208Zustandsdiagramm 9.1.2
........................................................................................................... 209Einf ügen von Zustandsdiagrammelementen
........................................................................................................... 210Erstellen von Zuständen, Aktivitäten und Transitionen
........................................................................................................... 216Zusammengesetzte Zustände
........................................................................................................... 219Codegenerierung anhand von Zustandsdiagrammen
........................................................................................................... 222Arbeiten mit Zustandsdiagrammcode
........................................................................................................... 228Zustandsdiagramm-Elemente
................................................................................................... 230Protokoll-Zustandsautomat 9.1.3
........................................................................................................... 231Einf ügen von Protokoll-Zustandsdiagramm-Elementen
........................................................................................................... 232Protokoll-Zustandsdiagramm-Elemente
................................................................................................... 234Use Case-Diagramm 9.1.4
................................................................................................... 235Kommunikationsdiagramm 9.1.5
........................................................................................................... 236Einf ügen von Kommunikationsdiagrammelementen
................................................................................................... 239Interaktionsübersichtsdiagramm 9.1.6
........................................................................................................... 240Einf ügen von Interaktionsübersichtselementen
................................................................................................... 244Sequenzdiagramm 9.1.7
........................................................................................................... 245Einf ügen von Sequenzdiagrammelementen...................................................................................................................... 247Lebenslinie
...................................................................................................................... 248Combined Fragment
...................................................................................................................... 252Interaction Use
...................................................................................................................... 252Gate
...................................................................................................................... 253Zustandsinvariante
...................................................................................................................... 253Nachrichten
........................................................................................................... 259Generieren von Sequenzdiagrammen anhand vonQuellcode
........................................................................................................... 262Generieren von Sequenzdiagrammen anhand vonEigenschaf ten
........................................................................................................... 264Generieren von Code anhand von Sequenzdiagrammen...................................................................................................................... 267Hinzufügen von Code zu einem Sequenzdiagramm
................................................................................................... 270Zeitverlaufsdiagramm 9.1.8
........................................................................................................... 271Einf ügen von Elementen des Zeitverlauf sdiagramms
........................................................................................................... 271Lebenslinie
........................................................................................................... 274Tick-Symbol
Altova UModel 20174
........................................................................................................... 275Auslösendes Ereignis
........................................................................................................... 275Zeitdauerbedingung
........................................................................................................... 276Zeitbedingung
........................................................................................................... 277Nachricht
................................................................................................................. 2799.2 Strukturdiagramme
................................................................................................... 279Klassendiagramm 9.2.1
........................................................................................................... 279Anp assen von Klassendiagrammen
........................................................................................................... 287Auß erkraf tsetzen von Basisklassenop erationen undImp lementieren von Schnittstellenop erationen
........................................................................................................... 288Erstellen von Getter / Setter-Methoden
........................................................................................................... 289Ball-and-socket Notation
........................................................................................................... 290Hinzuf ügen von Ausnahmeereignissen zu Methodeneiner Klasse
........................................................................................................... 291Generieren von Klassendiagrammen
................................................................................................... 294Kompositionsstrukturdiagramm 9.2.2
........................................................................................................... 295Einf ügen von Elementen einesKomp ositionsstrukturdiagramms
................................................................................................... 296Komponentendiagramm 9.2.3
................................................................................................... 297Deployment-Diagramm 9.2.4
................................................................................................... 297Objektdiagramm 9.2.5
................................................................................................... 298Paketdiagramm 9.2.6
........................................................................................................... 299Einf ügen von Paketdiagrammelementen
........................................................................................................... 301Generieren von Paketdiagrammen beim Imp ortieren vonCode oder Binärdateien
................................................................................................... 304Profildiagramm und Stereotype 9.2.7
........................................................................................................... 306Hinzuf ügen von Stereotyp en und Def inieren vonEigenschaf tswerten
........................................................................................................... 310Stereotyp e und Enumerationen
........................................................................................................... 312Benutzerdef inierte Stereotyp stile
........................................................................................................... 314Benutzerdef inierte Stereotyp symbole - Zuweisung
................................................................................................................. 3189.3 Zusätzliche Diagramme
................................................................................................... 318XML-Schema-Diagramme 9.3.1
........................................................................................................... 320Imp ortieren von XML-Schemas
........................................................................................................... 326Einf ügen von XML-Schema-Elementen
........................................................................................................... 330Erstellen und Generieren eines XML-Schemas
10 Austausch von Metadaten zwischen XMI undXML 334
5Altova UModel 2017
11 UModel-Unterstützung für die Arbeit imTeam 338
................................................................................................................. 34011.1 Erstellen und Bearbeiten von Unterprojektdateien
12 Versionskontrolle 348
................................................................................................................. 35012.1 Einrichten der Versionskontrolle
................................................................................................................. 35112.2 Unterstützte Versionskontrollsysteme
................................................................................................................. 35312.3 Versionskontrollbefehle
................................................................................................... 353Aus Versionskontrolle öffnen 12.3.1
................................................................................................... 355Versionskontrolle aktivieren 12.3.2
................................................................................................... 356Aktuellste Version holen 12.3.3
................................................................................................... 357Abrufen 12.3.4
................................................................................................... 358Ordner abrufen 12.3.5
................................................................................................... 359Auschecken 12.3.6
................................................................................................... 360Einchecken 12.3.7
................................................................................................... 361Auschecken rückgängig... 12.3.8
................................................................................................... 362Zu Versionskontrolle hinzufügen 12.3.9
................................................................................................... 364Von Versionskontrolle ausgliedern 12.3.10
................................................................................................... 365Aus Versionskontrolle freigeben 12.3.11
................................................................................................... 366Verlauf anzeigen 12.3.12
................................................................................................... 368Unterschiede anzeigen 12.3.13
................................................................................................... 369Eigenschaften anzeigen 12.3.14
................................................................................................... 370Status aktualisieren 12.3.15
................................................................................................... 370Versionskontrollmanager 12.3.16
................................................................................................... 370Versionskontrolle wechseln 12.3.17
................................................................................................................. 37212.4 Versionskontrolle mit Git
................................................................................................... 373Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-in 12.4.1
................................................................................................... 373Hinzufügen eines Projekts zur Git-Versionskontrolle 12.4.2
................................................................................................... 375Klonen eines Projekts anhand der Git-Versionskontrolle 12.4.3
13 UModel Diagrammsymbole 378
................................................................................................................. 37913.1 Aktivitätsdiagramm
................................................................................................................. 38013.2 Klassendiagramm
................................................................................................................. 38113.3 Kommunikationsdiagramm
................................................................................................................. 38213.4 Kompositionsstrukturdiagramm
................................................................................................................. 38313.5 Komponentendiagramm
Altova UModel 20176
................................................................................................................. 38413.6 Deployment-Diagramm
................................................................................................................. 38513.7 Interaktionsübersichtsdiagramm
................................................................................................................. 38613.8 Objektdiagramm
................................................................................................................. 38713.9 Paketdiagramm
................................................................................................................. 38813.10 Profildiagramm
................................................................................................................. 38913.11 Protokoll-Zustandsdiagramm
................................................................................................................. 39013.12 Sequenzdiagramm
................................................................................................................. 39113.13 Zustandsdiagramm
................................................................................................................. 39213.14 Zeitverlaufsdiagramm
................................................................................................................. 39313.15 Use Case-Diagramm
................................................................................................................. 39413.16 XML-Schema-Diagramm
14 Menüreferenz 396
................................................................................................................. 39714.1 Datei
................................................................................................................. 40214.2 Bearbeiten
................................................................................................................. 40514.3 Projekt
................................................................................................................. 41214.4 Layout
................................................................................................................. 41314.5 Ansicht
................................................................................................................. 41414.6 Extras
................................................................................................... 414Benutzerdefinierte Tools 14.6.1
................................................................................................... 414Anpassen... 14.6.2
........................................................................................................... 415Bef ehle
........................................................................................................... 415Symbolleisten
........................................................................................................... 416Extras
........................................................................................................... 419Tastatur
........................................................................................................... 419Menü
........................................................................................................... 420Op tionen
................................................................................................... 421Symbolleisten und Fenster wiederherstellen 14.6.3
................................................................................................... 421Optionen 14.6.4
................................................................................................................. 42814.7 Fenster
................................................................................................................. 42914.8 Hilfe
15 Code Generator 436
................................................................................................................. 43715.1 SPL (Spy Programming Language)
................................................................................................... 437Grundlegende SPL-Struktur 15.1.1
................................................................................................... 438Variablen 15.1.2
................................................................................................... 444Operatoren 15.1.3
7Altova UModel 2017
................................................................................................... 445Bedingungen 15.1.4
................................................................................................... 446Collections und foreach 15.1.5
................................................................................................... 448Subroutinen 15.1.6
........................................................................................................... 448Deklaration einer Subroutine
........................................................................................................... 449Subroutinenauf ruf
................................................................................................................. 45015.2 Fehlercodes
16 Lizenzinformationen 452
................................................................................................................. 45316.1 Electronic Software Distribution
................................................................................................................. 45416.2 Software-Aktivierung und Lizenzüberwachung
................................................................................................................. 45616.3 Rechte am geistigen Eigentum
................................................................................................................. 45716.4 Altova Endbenutzer-Lizenzvereinbarung
Index
Kapitel 1
UModel
© 2017 Altova GmbH
3UModel
Altova UModel 2017
1 UModel
UModel®2017 Basic Edition ist eine erschwingliche Modellierapplikation mit visuellerBenutzeroberfläche und zahlreichen, benutzerfreundlichen Funktionen, mit denen das Erlernenvon UML kein Problem mehr ist. UModel bietet viele hochspezifische Funktionen für dieImplementierung der nützlichsten Aspekte der UML 2.4 Spezifikation. UModel ist eine 32/64-BitWindows-Applikation, die auf Windows XP/Vista, Windows 7/8/10 und Windows Server2003/2008/2012/2016 läuft. Die 64-Bit-Version steht für die Enterprise und Professional Versionzur Verfügung.
UModel® 2017 unterstützt:
alle 14 UML 2.3 ModellierungsdiagrammeMDA (Model Driven Architecture)-Unterstützung, wodurch die Konvertierung zwischenverschiedenen 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 Projektbearbeitung3-Weg-ProjektzusammenführungProtokoll-ZustandsdiagrammeSysML-1.2-Diagramme (nur Enterprise/Professional Edition)Sequenzdiagrammgenerierung direkt anhand von QuellcodeCodegenerierung 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 VersionskontrollsystemeXML-Schema-DiagrammeBusiness 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ärdateienVerknüpfen von Diagrammen und Modellierungselementen mittels HyperlinksSyntaxfärbung in DiagrammenCascading Stylesunbegrenztes Rückgängigmachen und WiederherstellenGenerierung von Java-, C#- und Visual Basic-Code anhand von ModellenReverse Engineering von vorhandenem Java-, C#- und Visual Basic-Quellcodevollständiges Round-Trip Engineering mit Zusammenführung von Code und ModellXMI-Version 2.4 für UML 2.0, 2.1und 2.1.2, 2.2, 2.3, 2.4-Modellimport und -exportGenerierung von UModel Projektdokumentation
Dank dieser Funktionen können Entwickler - selbst Neulinge im Bereich der Software-Modellierung - rasch das volle Potenzial von UML ausschöpfen, um produktiver arbeiten undoptimale Ergebnisse erzielen zu können.
4 UModel
© 2017 Altova GmbHAltova UModel 2017
UML®, OMG™, Object Management Group™ und Unified Modeling Language™ sind entwedereingetragene Markenzeichen oder Markenzeichen der Object Management Group, Inc. in denUSA und/oder anderen Ländern.
Letzte Aktualisierung: 03.04.2017
Kapitel 2
Einführung in UModel
6 Einführung in UModel
© 2017 Altova GmbHAltova UModel 2017
2 Einführung in UModel
Altova Web site: Einführung in Altova UModel
UML (Unified Modeling Language) ist eine vollständige Modelliersprache, die jedoch nichtvorschreibt, welche Methode bei der Entwicklung, Code Generierung und beim Round-TripEngineering verwendet werden soll. UModel wurde so konzipiert, dass der Benutzer bei derModellierung vollkommen freie Hand hat:
UModel Diagramme können jederzeit und in jeder Reihenfolge erstellt werden; es mussbei der Modellierung keine vorgeschriebene Reihenfolge eingehalten werden.Code oder Modelle können auf Ebene eine Projekts, Pakets oder sogar einer Klassezusammengeführt werden. Bei UModel müssen kein Pseudocode oder Kommentare imgenerierten Code vorhanden sein, damit ein Round-Trip Engineering durchgeführt werdenkann.
Die Codegenerierung in UModel basiert auf SPL- (Spy Programming Language) Vorlagenund kann komplett angepasst werden. Änderungen werden automatisch bei derCodegenerierung erkannt.
Bei der Codegenerierung und dem Reverse Engineering werden derzeit die folgendenSprachen unterstützt:
Sprache Version
C# 1.2, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0
Java 1.4, 5.0 (1.5), 6, 7, 8
Visual Basic .NET 7.1, 8.0, 9.0
Anmerkung: C# 7-Unterstützung steht nicht zur Verfügung, wenn UModel als Visual StudioPlug-in ausgeführt wird.
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 UML2.4.1)Beim Hinzufügen von Eigenschaften oder Operationen bietet UModel Eingabehilfen zurAuswahl von Typen, Spezialisierung und Klassifizierung und anderen Eigenschaften, dieauch 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, Umrandungenusw.) können auf Ebene von Projekten, Knoten/Zeilen, Elementfamilien und Elementenhierarchisch vollständig angepasst werden.
In Use-Case-Diagrammen können anpassbare Akteure definiert werden, mit denenTerminals 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 inModeldiagrammen über das Kontextmenü gefunden/markiert werden.
© 2017 Altova GmbH
7Einführung in UModel
Altova UModel 2017
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.
Anmerkung:Dieses Dokument enthält keine Beschreibung oder Erläuterung von UML (UnifiedModeling Language); vielmehr wird darin beschrieben, wie die UModelModellierungsapplikation verwendet wird und wie Code modelliert sowie ein Round-TripEngineering durchgeführt wird.
Kapitel 3
UModel Tutorial
10 UModel Tutorial
© 2017 Altova GmbHAltova UModel 2017
3 UModel Tutorial
In diesem Tutorial wird der Reihe nach beschrieben, wie man im Allgemeinen beim Erstellen einesModellierungsprojekts in UModel vorgeht.
Der Großteil des Tutorials ist dem Forward Engineering gewidmet, d.h. dem Erstellen von UML-Diagrammen in UModel und dem Generieren von Code. Anschließend wird auf das Round-TripEngineering eingegangen. In den Abschnitten über Round-Trip Engineering wird der Vorgangsowohl von der Code-Seite als auch von der Modellseite aus beschrieben.
Im Tutorial werden die folgenden UML-Diagramme beschrieben und wie die verschiedenenModellierungselemente darin verwendet werden. Es werden die folgenden Diagramme und diedamit in Zusammenhang stehenden Vorgänge beschrieben:
Forward Engineering:Use Cases (Anwendungsfälle)KlassendiagrammeObjektdiagrammeKomponentendiagrammeDeployment-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 einerProjektdatei)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 andSettings\All Users\Application Data\Altova zur Verfügung. Wenn ein Einzelbenutzer dieApplikation zum ersten Mal startet, werden die Beispieldateien für diesen Ordner in den OrdnerC:\Documents and Settings\<username>\My Documents\Altova\UModel2017\UModelExamples\ kopiert. Verschieben, bearbeiten oder löschen Sie daher die Beispieldateienim Anfangsverzeichnis ...\All Users\.... nicht.
BankView-start.umpist die UModel-Projektdatei, in der sich die Tutorial-Beispieldatei im Anfangszustandbefindet. In dieser Phase enthält sie einige Modell-Diagramme sowie Klassen, Objekteund andere Modellelemente. Während Sie das Tutorial durcharbeiten, werden nach undnach neue Pakete, Modelldiagramme und viele andere Elemente hinzugefügt, um Ihnenzu demonstrieren, wie leicht Sie mit UModel Applikationen modellieren können. BeachtenSie bitte, dass die Syntaxüberprüfung bei dieser Datei Fehler und Warnmeldungenausgibt. Im Tutorial wird beschrieben, wie Sie diese Probleme beheben können.
BankView-finish.ump
© 2017 Altova GmbH
11UModel Tutorial
Altova UModel 2017
ist die UModel Projektdatei, in der Sie das Tutorial-Beispiel im Endzustand sehen. DieseProjektdatei wird beim Generieren von Code und beim Synchronisieren des Codes mitUModel verwendet.
Der OrgChart.zip-Ordner in diesem Ordner wird für das Round-Trip Engineeringverwendet. Entpacken Sie den Ordner bitte in den Ordner ..\UmodelExamples, bevor Siemit dem Abschnitt beginnen.
Weitere Beispieldateien sowohl für die Programmiersprache Java als auch C# liegen ebenfalls imselben Verzeichnis: Bank_Java.ump, Bank_CSharp.ump und Bank_MultiLanguage.ump.Diese Projektdateien enthalten auch Sequenzdiagramme, die weiter hinten in dieserDokumentation beschrieben sind.
Im Abschnitt "Projekte und Code Engineering" finden Sie eine Anleitung, wie man ein Projekt vonGrund auf neu erstellt und Code generiert.
12 UModel Tutorial Starten von UModel
© 2017 Altova GmbHAltova UModel 2017
3.1 Starten von UModel
Nachdem Sie UModel auf Ihrem Computer installiert haben:
1. Starten Sie UModel mit einem Doppelklick auf das UModel-Symbol auf Ihrem Desktopoder 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 linkenSeite 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 oderumbenannt 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 eineURL ö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 einigevordefinierte Pakete. Beachten Sie, dass das Hauptfenster zu diesem Zeitpunkt leer ist.
© 2017 Altova GmbH
Starten von UModel 13UModel Tutorial
Altova UModel 2017
Das Modell-Struktur-Fenster bietet verschiedene Ansichten Ihres Modellierungsprojekts:
Auf dem Register Modell-Struktur werden alle Modellierungselemente Ihres UModel-Projekts angezeigt. Elemente können auf diesem Register mit Hilfe der Standard-Bearbeitungstasten sowie Drag and Drop direkt manipuliert werden.Auf dem Register Diagramm-Struktur haben Sie schnellen Zugriff auf dieModellierungsdiagramme Ihres Projekts, egal an welcher Stelle in der Projektstruktur sichdiese befinden. Diagramme werden nach Diagrammtyp gruppiert.
Das Register Favoriten ist eine konfigurierbare Ablage für Modellierungselemente. Mitdem Kontextmenü-Befehl "Zu Favoriten hinzufügen" können Sie jede Art vonModellierungselement auf dieses Register platzieren.
Das Fenster "Eigenschaften" bietet zwei Ansichten bestimmter Modelleigenschaften:
Auf dem Register Eigenschaften sehen Sie die Eigenschaften des aktuell ausgewähltenElements aus dem Fenster "Modell-Struktur" oder "Diagramm". Auf diesem Registerkönnen Elementeigenschaften definiert oder aktualisiert werden.Auf dem Register Stile sehen Sie Attribute von Diagrammen oder Elementen, die in derDiagrammansicht angezeigt werden. Diese Stilattribute lassen sich in zwei allgemeine
14 UModel Tutorial Starten von UModel
© 2017 Altova GmbHAltova UModel 2017
Gruppen unterteilen: Formatierungen und Anzeigeeinstellungen.Auf dem Register Hierarchie sehen Sie alle Beziehungen des aktuell ausgewähltenModellierungselements in zwei unterschiedlichen Ansichten. Das Modellierungselementkann 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 dokumentierenkö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 Paketdiagramm
Klassendiagramm Profildiagramm
Kommunikationsdiagramm Sequenzdiagramm
Komponentendiagramm Zustandsdiagramm
Kompositionsstrukturdiagramm Zeitverlaufsdiagramm
Deployment-Diagramm Use Case-Diagramm
Interaktionsübersichtsdiagramm XML-Schema-Diagramm
Objektdiagramm Business Process ModelingNotation
Elementtypen:
Ein Element, das im aktiven Diagramm gerade sichtbar ist, wird mit einem blauen Punkt amunteren 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
© 2017 Altova GmbH
Starten von UModel 15UModel Tutorial
Altova UModel 2017
Komponente
Knoten
Artefakt
Schnittstelle
Beziehungen (/Paket)Einschränkungen
16 UModel Tutorial Use Cases
© 2017 Altova GmbHAltova UModel 2017
3.2 Use Cases
Altova Website: UML Use Case-Diagramme
Ziel dieses Tutorial-Abschnitt ist es:
ein neues Paket zum Projekt hinzuzufügenein neues Use Case-Diagramm zum Projekt hinzuzufügenUse Case-Elemente zum Diagramm hinzuzufügen und die Abhängigkeiten zwischen denElementen zu definierenElemente 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.
© 2017 Altova GmbH
Use Cases 17UModel Tutorial
Altova UModel 2017
Dem Paket wurde nun in der Modell-Struktur-Ansicht ein Use Case-Diagrammhinzugefügt und im Diagramm-Fenster wurde ein Diagramm-Register angelegt, dasautomatisch einen Standardnamen erhielt.
3. Doppelklicken Sie auf dem Register "Modell-Struktur" auf diesen Namen, ändern Sie ihnin "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 dasDiagrammfenster, um das Element einzufügen.Es wird ein Element "UseCase1" eingefügt. Beachten Sie, dass das Element und seinName aktuell ausgewählt sind und dass seine Eigenschaften auf dem Register"Eigenschaften" angezeigt werden.
18 UModel Tutorial Use Cases
© 2017 Altova GmbHAltova UModel 2017
3. Ändern Sie den Titel in "get account balance" und drücken Sie zur Bestätigung dieEingabetaste. Doppelklicken Sie auf den Titel, wenn er nicht aktiv ist.
Beachten Sie, dass die Größe des Use Case automatisch an die Textlänge angepasstwird.
Modellelemente haben verschiedene Verbindungsziehpunkte und andere Elemente, mitdenen Sie diese bearbeiten können.Anmerkung: Durch Drücken von Strg + Eingabetaste können Sie einen mehrzeiligen UseCase-Namen erstellen.
Bearbeiten von UModel Elementen: Ziehpunkte und Bereiche1. 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".
© 2017 Altova GmbH
Use Cases 19UModel Tutorial
Altova UModel 2017
3. Klicken Sie auf den Ziehpunkt, ziehen Sie die Assoziationslinie nach rechts auf denAnwendungsfall (Use case) "get account balance".
Zwischen Dem Akteur und dem Anwendungsfall wurde nun eine Assoziation erstellt. DieEigenschaften der Assoziation sind auch auf dem Register "Eigenschaften" zu sehen.Die neue Assoziation wurde unter dem Element "Beziehungen" des Use Case View-Pakets hinzugefügt.
4. Klicken Sie auf den Anwendungsfall (Use Case) und ziehen Sie ihn nach rechts, um ihnneu 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 dasSymbol zum Reduzieren am linken Rand der Use Case-Ellipse.
Der Bereich "extension points" wird nun ausgeblendet.
20 UModel Tutorial Use Cases
© 2017 Altova GmbHAltova UModel 2017
Bitte beachten Sie:
Ein blauer Punkt neben einem Elementsymbol auf dem Register"Modell-Struktur" bedeutet, dass das Element auf dem aktuellen Diagrammregistersichtbar ist. Wenn Sie die Größe des Akteurs anpassen, wird auch das Textfeldangepasst, das auch mehrere Zeilen enthalten kann. Mit Strg + Eingabetaste wird eineZeilenschaltung 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 gleichzeitigdie 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 Sieanschließend die Strg-Taste los.
3. Geben Sie dem ersten Use Case den Namen "get account balance sum" und demzweiten den Namen, "generate monthly revenue report".
4. Klicken Sie auf das Einklappsymbol der einzelnen Use Case-Ellipsen um den extension-Bereich auszublenden.
5. Klicken Sie auf den Akteur und erstellen Sie mit Hilfe des Assoziationsziehpunkts eineAssoziation zwischen "Standard User" und "get account balance sum".
© 2017 Altova GmbH
Use Cases 21UModel Tutorial
Altova UModel 2017
So erstellen Sie eine "include"-Abhängigkeit zwischen Use Cases (und somit einenuntergeordneten 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 dasinclude-Stereotyp angezeigt.
Einfügen von benutzerdefinierten Akteuren:Beim Akteur im Use Case "generate monthly revenue report" handelt es sich nicht um einePerson, sondern um einen automatisierten Batch-Auftrag, der von einem Bankcomputerausgeführt wird.
1. Fügen Sie mit Hilfe des Symbolleistensymbols "Akteur" einen Akteur in das Diagrammein.
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.
22 UModel Tutorial Use Cases
© 2017 Altova GmbHAltova UModel 2017
Bei Auswahl von "Vorschau" wird im Dialogfeld eine Vorschau der ausgewählten Dateiangezeigt.
6. Klicken Sie auf OK, um die Einstellungen zu bestätigen und fügen Sie den neuen Akteurein.
7. Verschieben Sie den neuen Akteur "Bank" und platzieren Sie ihn rechts vom unterstenUse Case.
8. Klicken Sie in der Symbolleiste auf das Symbol "Assoziation" und ziehen Sie esvom 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 dieRGB-Werte 82.82.82.
Ziehen von Elementen - AusrichtungshilfslinienWenn Sie Komponenten in einem Diagramm mit der Maus ziehen, erscheinen Hilfslinien, andenen Sie ein Element an jedem anderen Element im Diagramm ausrichten können. Diese Optionkann mit Hilfe der Menüoption Extras | Optionen | Ansicht - Gruppe "Ausrichtung" "Hilfslinienaktivieren" aktiviert bzw. deaktiviert werden.
© 2017 Altova GmbH
Use Cases 23UModel Tutorial
Altova UModel 2017
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 diefolgenden 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" , um alle Ellipsen parallelauszurichten.
24 UModel Tutorial Use Cases
© 2017 Altova GmbHAltova UModel 2017
Bitte beachten Sie:Sie können auch mit Hilfe der Strg-Taste mehrere Elemente auswählen.
© 2017 Altova GmbH
Klassendiagramme 25UModel Tutorial
Altova UModel 2017
3.3 Klassendiagramme
Altova Website: UML-Klassendiagramme
Ziel dieses Tutorial-Abschnitts ist es:
eine neue abstrakte Klasse mit dem Namen "Account" sowie Attribute und Operationenhinzuzufügeneine 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 dasKlassendiagrammsymbol unterhalb des Pakets "BankView" doppelklicken, um dasselbeErgebnis zu erzielen.
Im Klassendiagramm sehen Sie zwei konkrete Klassen, die durch eine Kompositions-Assoziationverbunden sind.
26 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
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 rechtsvon 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 dieEingabetaste, (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 dieKlasse abstrakt zu machen.
4. Klicken Sie in das Textfeld von "Codedateiname" und geben Sie Account.java ein, umden Dateinamen der Java-Klasse zu definieren.
© 2017 Altova GmbH
Klassendiagramme 27UModel Tutorial
Altova UModel 2017
Der Name der Klasse wird nun kursiv angezeigt, da abstrakte Klassen kursiv angezeigtwerden.
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 einenDoppelpunkt ":" 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ückgabewert-Datentyp "float" einzufügen.Beachten Sie bitte, dass die Groß- und Kleinschreibung in Dropdown-Listen eine Rollespielt!
28 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
4. Fahren Sie in derselben Zeile fort, indem Sie "=0" anhängen, um den Standardwert zudefinieren.
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önneneinen 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 fahrenSie in derselben Zeile fort.
6 Geben Sie "bankAPI" ein, gefolgt von einem Doppelpunkt.
© 2017 Altova GmbH
Klassendiagramme 29UModel Tutorial
Altova UModel 2017
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 ihnanschließ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-konformenSymbole 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 Projektgelöscht werden soll. Klicken Sie auf "Ja", um Operation1 aus der Klasse und demProjekt zu löschen.
Bitte beachten Sie:Wenn Sie die Operation nur aus der Klasse im Diagramm löschen möchten, nicht aberaus dem Projekt, drücken Sie Strg + Entf. Sie können auch eine Bestätigungsmeldung
30 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
aktivieren, die Sie beim Löschen von Objekten bestätigen müssen. Nähere Informationendazu 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. Dazumüssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1" in dieKlasse "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 Accountmarkiert.
3. Drücken Sie die Entf-Taste, um die Operation aus der Klasse und dem Projekt zulöschen! Beachten Sie, dass Sie durch Drücken von F4 beinahe jedes Modellierungselement in derModell-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 derBenutzerreferenz 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 vonder 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. Diebeiden Klassen werden durch einen Kompositions-Assoziationspfeil verbunden.
© 2017 Altova GmbH
Klassendiagramme 31UModel Tutorial
Altova UModel 2017
2. Doppelklicken Sie in der Klasse "Bank" auf den neuen Eintrag Property1 und ändern Sieihn in "accounts". Stellen Sie sicher, dabei die Account-Typdefinition (angezeigt inblaugrün) nicht gelöscht wird.
3. Drücken Sie die Ende-Taste, um den Textcursor an das Ende der Zeile zu platzieren4. 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 dieEingabetaste.
3.3.1 Erstellen von abgeleiteten Klassen
Ziel dieses Tutorialabschnitts ist es:
Hinzufügen eines neuen Klassendiagramms namens "Account Hierarchy" zum ProjektEinfügen bestehender Klassen und Erstellen einer Klasse "Savings account"Erstellen von drei abgeleiteten Klassen der abstrakten Basisklasse "Account" mit Hilfevon 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.
32 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
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".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.
© 2017 Altova GmbH
Klassendiagramme 33UModel Tutorial
Altova UModel 2017
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 zubankview, welches das aktuelle Klassendiagramm Account Hierarchy enthält.
2. Doppelklicken Sie auf den Klassennamen und ändern Sie ihn in SavingsAccount.
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
34 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
den Datentyp "float" aus der Dropdown-Liste auszuwählen. Drücken Sie zweimal dieEingabetaste, 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" undgeben 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 Standard-Tastenkombinationen von einer Klasse in die andere kopiert oder verschoben werden. Diesfunktioniert in folgenden Fällen:
innerhalb einer Klasse auf dem Diagramm-Registerzwischen verschiedenen Klassen auf dem Diagramm-Registerin der Modell-Struktur-Ansichtzwischen verschiedenen UML-Diagrammen durch Ziehen der kopierten Daten auf einanderes Diagrammregister. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und Einfügen inUModel Diagrammen.
1. Erweitern Sie die Klasse Account in der Modell-Struktur.2. Rechtsklicken Sie auf die Operation collectAccountInfo und wählen Sie Kopieren.
© 2017 Altova GmbH
Klassendiagramme 35UModel Tutorial
Altova UModel 2017
3. Rechtsklicken Sie in der Modell-Struktur auf die Klasse SavingsAccount und wählenSie Einfügen.Die Operation wird in die Klasse "SavingsAccount" kopiert, wobei diese Klasseautomatisch erweitert wird, um die neue Operation anzuzeigen.
Die neue Operation ist nun auch im Klassendiagramm in der Klasse "SavingsAccount" zusehen.
Bitte beachten Sie:Sie können diese Ergebnisse in der Modell-Struktur sowohl mit Kopieren/Einfügen (Strg Cbzw. V) als auch mit Drag & Drop erzielen. Eventuell müssen Sie die Sortieroptionendeaktivieren, um die Operation zwischen bestimmten Elementen platzieren zu können.
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 abgeleitetekonkrete Klassen erstellen.
1. Klicken Sie in der Symbolleiste auf das Symbol "Generalisierung" und halten Siedie Strg-Taste gedrückt.
36 UModel Tutorial Klassendiagramme
© 2017 Altova GmbHAltova UModel 2017
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 erstellteGeneralisierung.
4. Ziehen Sie die Pfeilspitz von der Klasse SavingsAccount auf die zuvor erstellteGeneralisierung: lassen Sie jetzt die Strg-Taste los.
5. Zwischen den drei Unterklassen und der Überklasse "Account" werdenGeneralisierungspfeile erstellt.
© 2017 Altova GmbH
Objektdiagramme 37UModel Tutorial
Altova UModel 2017
3.4 Objektdiagramme
Altova Website: UML-Objektdiagramme
Ziel dieses Tutorialabschnittes ist es:
zu zeigen, wie Klassen- und Objektdiagramme in einem Diagramm kombiniert werdenkönnen, um einen Schnappschuss des Objekts zu einem bestimmten Zeitpunkt zuerhalten.Objekte/Instanzen zu erstellen und die Beziehungen zwischen diesen zu definierenAssoziationen/Objektbeziehungen zu formatierenreale Daten in Objekte/Instanzen einzugeben
So öffnen Sie das Objektdiagramm:1. Doppelklicken Sie auf das Sample Accounts-Diagrammsymbol unter dem bankview-
Paket (oder unter Objektdiagramme auf dem Register "Diagramm-Struktur").
Die Klasse "Bank" sowie zwei damit in Beziehung stehende Objekte/Instanzen werdenim Objektdiagramm angezeigt.
AltovaBank:Bank ist das Objekt/die Instanz der Klasse "Bank", während John'schecking: CheckingAccount eine Instanz der Klasse CheckingAccount ist.
Einfügen einer Klasse in ein Objektdiagramm:Klicken Sie in der Modell-Struktur auf das Account-Klassensymbol undziehen Sie es auf das Register "Sample Accounts".Die zuvor im BankView Main-Diagramm definierte Kompositions-Assoziation wirdautomatisch erstellt.
38 UModel Tutorial Objektdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 klickenSie 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 denEintrag CreditCardAccount aus.
Beachten Sie: Bei Rechtsklick auf eine Instanzspezifikation und Auswahl von Knoteninhalt ein-/ausblenden können Sie den Inhalt von Objekten ein- oderausblenden.
© 2017 Altova GmbH
Objektdiagramme 39UModel Tutorial
Altova UModel 2017
So fügen Sie ein neues Objekt in der Modell-Struktur-Ansicht hinzu (um es dann in einDiagramm einzufügen):
1. Rechtsklicken Sie in der Modell-Struktur-Ansicht auf das bankview-Paket und wählenSie Neues Element | Instanzspezifikation.
2. Ändern Sie den Standard-Objektnamen in John's Saving und drücken Sie zumBestä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 dasRegister "Sample Accounts" und platzieren Sie es unterhalb von "John's credit".
40 UModel Tutorial Objektdiagramme
© 2017 Altova GmbHAltova UModel 2017
Erstellen von "Objektbeziehungen" zwischen Objekten:Objektbeziehungen sind die Instanzen von Klassenassoziationen und beschreiben dieAssoziationen zwischen Objekten/Instanzen zu einem bestimmten Zeitpunkt.
1. Klicken Sie auf die bestehende Objektbeziehung (Assoziation) zwischen AltovaBankund John's Checking.
2. Klicken Sie auf dem Register "Eigenschaften" auf das Dropdown-Listenfeld classifier undwählen Sie den Eintrag Account - Bank. Die Objektbeziehung ändert sich nun gemäß den Klassendefinitionen in eineKompositions-Assoziation.
3. Klicken Sie in der Symbolleiste auf das Instanzspezifikation-Symbol undpositionieren Sie den Cursor über die Klasse John's Credit.Der Cursor wird nun als +-Symbol angezeigt.
4. Ziehen Sie den Cursor vom Objekt John's Credit zu AltovaBank, um die beiden Objektezu verknüpfen.
4. Ändern Sie den Typ der Objektbeziehung über das Dropdown-Listenfeld classifier aufdem Register "Eigenschaften" in Account - Bank.
5. Erstellen Sie wie oben beschrieben eine Objektbeziehung zwischen John's Saving undAltovaBank.
© 2017 Altova GmbH
Objektdiagramme 41UModel Tutorial
Altova UModel 2017
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. Klicken Sie in die entsprechenden Slots der einzelnen Objekte und geben SieBeispieldaten ein.
2. Doppelklicken Sie z.B.. im Objekt John's Checking in den balance-Slot und geben Sieals Kontostand 11,975.00 ein (englische Dezimalschreibweise).
3. Füllen Sie den Rest der Daten aus, um den Status der aktuellen Instanz zu sehen.
42 UModel Tutorial Objektdiagramme
© 2017 Altova GmbHAltova UModel 2017
© 2017 Altova GmbH
Komponentendiagramme 43UModel Tutorial
Altova UModel 2017
3.5 Komponentendiagramme
Ziel dieses Tutorialabschnittes ist:
zu zeigen, wie Klassen in ein Komponentendiagramm eingefügt werdenRealisierungsbeziehungen zwischen den Klassen und der Komponente "BankView" zuerstellenzu zeigen, wie Zeileneigenschaften geändert werdenKomponenten in ein Komponentendiagramm einzufügen und Verwendungsbeziehungenzu 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 bankview-Paket.
2. Ziehen Sie sie in das Komponentendiagramm.Die Klasse wird mit allen ihren Bereichen angezeigt.
44 UModel Tutorial Komponentendiagramme
© 2017 Altova GmbHAltova UModel 2017
3. Klicken Sie auf beide Einklappsymbole, bis nur mehr der Bereich mit dem Klassennamenangezeigt 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 "frombankview" angezeigt.
So erstellen Sie Realisierungsbeziehungen zwischen einer Klasse und einerKomponente:
1. Klicken Sie in der Symbolleiste auf das Realisierungssymbol .2. Ziehen Sie den Pfeil von SavingsAccount auf die Komponente BankView.
© 2017 Altova GmbH
Komponentendiagramme 45UModel Tutorial
Altova UModel 2017
3. Klicken Sie auf den Ziehpunkt Komponentenrealisierung der Klasse "Account" (amunteren Rand der Klasse) und ziehen Sie ihn auf die Komponente "BankView".
Sie können auf beide Arten Realisierungsbeziehungen erstellen. Es gibt noch eineweitere Methode, mit der Sie nur in der Modell-Struktur Realisierungsbeziehungenerstellen 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
46 UModel Tutorial Komponentendiagramme
© 2017 Altova GmbHAltova UModel 2017
Symbole, so genannte Wegpunkte angezeigt. Sie können darauf klicken und sieverschieben, um Linienmerkmale zu ändern. Ändern Sie die Linieneigenschaften IhrenWü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 aktuelldefinierten Systembeziehungen zwischen Komponenten und Schnittstellen angezeigt.
2. Klicken Sie in der Modell-Struktur auf die BankView GUI-Komponente unterhalb desComponent View | BankView-Pakets und ziehen Sie sie auf das DiagrammregisterOverview.Das Paket, das die eingefügte Komponente enthält, wird im Namensbereich "fromBankView" 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 Tutorialbeschriebenen) "Forward Engineering" erzeugt wird.
So erstellen Sie eine Verwendungsbeziehung zwischen Schnittstellen undKomponenten:
© 2017 Altova GmbH
Komponentendiagramme 47UModel Tutorial
Altova UModel 2017
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 einemsupplier-Element verbunden. In diesem Fall verwendet die Schnittstelle"IBankInterfaceAPI" die Dienste der Komponenten "BankView" und "BankViewGUI".
48 UModel Tutorial Deployment-Diagramme
© 2017 Altova GmbHAltova UModel 2017
3.6 Deployment-Diagramme
Ziel dieses Tutorialabschnittes ist es:
die Artefakt-Manifestation von Komponenten zu zeigeneinen neuen Knoten und eine Abhängigkeit zu einem Deployment-Diagramm(Verteilungsdiagramm) hinzuzufügenArtefakte 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 View-
Diagrammpaket und doppelklicken Sie auf das Artefakt-Symbol.
In diesem Diagramm sehen Sie die Manifestation der Komponenten Bank API client undBankView 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 desSystems wird angezeigt, welches derzeit nur den Knoten "Home PC" enthält.
© 2017 Altova GmbH
Deployment-Diagramme 49UModel Tutorial
Altova UModel 2017
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 vomKnoten "Home PC", um den Knoten einzufügen.
2. Benennen Sie den Knoten in "Bank" um und ziehen Sie an einer der Kanten, um ihn zuvergrößern.
So erstellen Sie eine Abhängigkeit zwischen zwei Knoten:
1. Klicken Sie auf das Abhängigkeitssymbol und ziehen Sie es vom Home PC-Knotenzum 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.
50 UModel Tutorial Deployment-Diagramme
© 2017 Altova GmbHAltova UModel 2017
Bitte beachten Sie:Nachdem Sie auf den Abhängigkeitspfeil (oder eines der benannten Elemente) geklickthaben, 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 zwischendiesen: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 undBankView.jar-Artefakte und platzieren Sie sie auf den Diagrammhintergrund (Für jedesArtefakt werden Deployment-Abhängigkeiten angezeigt).
2. Klicken Sie auf das BankView.jar-Artefakt und ziehen Sie es auf den Home PC-Knoten. 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 desKnoten mitverschoben.
© 2017 Altova GmbH
Deployment-Diagramme 51UModel Tutorial
Altova UModel 2017
4. Klicken Sie in der Symbolleiste auf das Abhängigkeitssymbol und halten Sie dieStrg-Taste gedrückt.
5. Ziehen Sie es vom BankView.jar-Artefakt zum BankAddresses.ini-Artefakt und haltenSie 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, wirdautomatisch 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 Projektgelö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 aberaus 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 Artefaktsangezeigt.
52 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2017 Altova GmbHAltova UModel 2017
3.7 Round-Trip Engineering (Modell - Code - Modell)
Altova Website: UML-Codegenerierung und UML Round-Trip Engineering
Ziel dieses Tutorialabschnittes ist:
die Durchführung einer Projektsyntaxüberprüfungdie Generierung von Projektcodedas 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 diesechs 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. Dergenerierte Code wird anschließend in diesem Verzeichnis abgelegt. Komponenten müssen einzeln so definiert werden, dass Sie in den Code Engineering-Vorgang 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 Round-Trip 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 dieEinstellungen 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 neuenOrdners, um einen neuen Ordner anzulegen. Der Pfad wird nun im Feld "directory"angezeigt.
© 2017 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 53UModel Tutorial
Altova UModel 2017
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 verwendenmöchten, wählen Sie die Menüoption Extras | Optionen | Code Engineering undwählen Sie in der Gruppe Namespace für Codedateipfad verwenden dieentsprechende Option aus.
So schließen Sie Komponenten in den Codegenerierungsvorgang ein oder nehmendiese 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).
54 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2017 Altova GmbHAltova UModel 2017
Ü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 wurdenicht 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.
© 2017 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 55UModel Tutorial
Altova UModel 2017
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 diesesProjekt generieren. Nähere Informationen dazu finden Sie unter Überprüfen derProjektsyntax.
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ähereInformationen finden Sie unter Merge Programmcode von UMode-Projekt
56 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2017 Altova GmbHAltova UModel 2017
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.
© 2017 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 57UModel Tutorial
Altova UModel 2017
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 dasRegister "Modell von Code" aktiv ist. Für das Tutorial müssen keine Änderungenvorgenommen werden. Nähere Informationen siehe Merge UModel Projekt aus Code
5. Klicken Sie auf OK, um das Modell aus dem Code zu überführen.
58 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2017 Altova GmbHAltova UModel 2017
6. Klicken Sie auf das Register Account Hierarchy, um das Ergebnis des Merge-Vorgangszu sehen.
Die neu zum Code hinzugefügte Methode (getInterestRate...) generiert eine neue Operation in der Klasse "SavingsAccount" von UModel.
© 2017 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 59UModel Tutorial
Altova UModel 2017
3.8 Round-Trip Engineering (Code - Modell - Code)
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 wurdein UModel eine neue Klasse zum Projekt hinzuzufügenden 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 vonCode 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.
4. Klicken Sie auf die Durchsuchen-Schaltfläche und wählen Sie das VerzeichnisOrgChart aus dem Ordner ...\UModelExamples.
60 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2017 Altova GmbHAltova UModel 2017
5. Damit UModel Klassen- und Paketdiagramme anhand des Quellcodes generiert,aktivieren Sie das Kontrollkästchen "Diagrammgenerierung aktivieren" und klickenSie auf "Weiter".
6. Wählen Sie die Optionen Einzelnes Diagramm generieren und/oder Diagramm proPaket generieren, wenn Sie danach gefragt werden. Sie können die Diagrammstilespäter gegebenenfalls ändern.
7. Klicken Sie zum Fortfahren auf "Weiter". In diesem Dialogfeld können Sie dieEinstellungen für die Generierung von Paketabhängigkeiten definieren.
© 2017 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 61UModel Tutorial
Altova UModel 2017
8. Klicken Sie auf "Fertig stellen". Wenn Sie dazu aufgefordert werden, speichern Sie dasneue Modell in einem Verzeichnis auf Ihrem Rechner. Die Daten werden während derEingabe 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 vonOrgChart":
62 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2017 Altova GmbHAltova UModel 2017
Die ausgeblendeten Klassen, aus denen OrgChart besteht, werden auf dem Hauptregisterangezeigt.
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
© 2017 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 63UModel Tutorial
Altova UModel 2017
Klasse CompanyType ein.
3. Fügen Sie mittels der Taste F8 in diesem Beispiel die folgenden neue Operationen zurKlasse 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.
64 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2017 Altova GmbHAltova UModel 2017
2. Klicken Sie in der Modellstruktur auf die neue Klasse "CompanyType" und ziehen Sie sienach oben auf die OrgChart-Komponente unterhalb des Component View-Pakets. Eserscheint eine Info, wenn der Mauszeiger sich über einer Komponente befindet.
Mit dieser Methode wird eine Realisierung zwischen einer Klasse und einer Komponenteerstellt, sodass Sie keine Komponenten- oder Deployment-Diagramme verwendenmüssen. Erweitern Sie das Element Beziehungen unterhalb der Komponente"Orgchart" um die neu erstellte Realisierung zu sehen.
© 2017 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 65UModel Tutorial
Altova UModel 2017
Merge von Programmcode aus einem Paket
1. Rechtsklicken Sie auf das Paket OrgChart, wählen Sie Code Engineering | MergeProgrammcode von UModel-Paket und bestätigen Sie den Vorgang mit derEingabetaste.
Im Meldungsfenster wird die Syntaxüberprüfung angezeigt, die durchgeführt wird, und derStatus 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 entwederauskommentiert oder gelöscht, je nachdem, welche Option im Dialogfeld"Synchronisierungseinstellungen" in der Gruppe "Code beim Löschen" ausgewähltwurde.
Sie wissen nun, wie man ein Modellierungsprojekt mit Hilfe von Forward Engineering erstellt undhaben ein komplettes Round-Trip Engineering durchgeführt. Im restlichen Teil dieserDokumentation erfahren Sie, wie man die besten Ergebnisse beim Erstellen von Modellen mitUModel erzielt.
Kapitel 4
UModel Benutzeroberfläche
68 UModel Benutzeroberfläche
© 2017 Altova GmbHAltova UModel 2017
4 UModel Benutzeroberfläche
UModel besteht aus einer Reihe von Fensterbereichen auf der linken Seite und einem größerenDiagrammregister auf der rechten Seite. Über die Fensterbereiche auf der linken Seite können SieIhr UModel-Projekt nach verschiedenen Aspekten anzeigen bzw. darin navigieren und Daten direkteditieren.
Die Fensterbereiche nennen sich: Modell-Struktur, Eigenschaften und Übersicht. Der Arbeits-/Ansichtsbereich rechts davon ist das UModel-Diagrammregister, auf dem derzeit dasKlassendiagramm des BankView Main-Pakets angezeigt wird.
Bitte beachten Sie:Alle Fensterbereiche sowie alle Diagrammregister können über die "Suchen"-Dropdown-Liste in der Hauptsymbolleiste (im Screenshot unten enthält sie den Text "account")oder durch Drücken von Strg + F durchsucht werden.
© 2017 Altova GmbH
Modell-Struktur 69UModel Benutzeroberfläche
Altova UModel 2017
4.1 Modell-Struktur
Register "Modell-Struktur"Über das Register "Modell-Struktur" können Sie Modellelemente direkt in der Modell-Strukturmanipulieren und bestimmte Elemente auf dem Register "Design" anzeigen, bzw. darinnavigieren. 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ängtvom ausgewählten Element ab.
Modellelemente im Modell-Strukturbereich können direkt manipuliert werden. Sie könnenFolgendes tun:
hinzufügen /einfügenkopieren oder verschiebenlöschenumbenennennach verschiedenen Kriterien sortiereneinschrä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, wirdeine Kopie erstellt.
In manchen Fällen wird beim Ziehen von Elementen eine Meldung angezeigt, dass dieOption "keine Sortierung" aktiviert werden muss, damit Sie die Aktion durchführen
70 UModel Benutzeroberfläche Modell-Struktur
© 2017 Altova GmbHAltova UModel 2017
können. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren undEinfügen in UModel Diagrammen.
Sortieren von Elementen in der Modell-Struktur (unter Aktivierung der Option "keineSortierung"):
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 nichtumbenannt 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 wirdgleichzeitig auch aus dem Diagrammregister gelöscht, falls es dort zu sehen ist, sowieaus dem Projekt. Mit Hilfe von Strg + Entf können Elemente aus einem Diagrammgelöscht werden, ohne auch aus dem Projekt gelöscht zu werden. Nähere Informationendazu 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 demDiagrammregister 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 Profildiagramm
Klassendiagramm Sequenzdiagramm
Kommunikationsdiagramm Zustandsdiagramm
Komponentendiagramm SysML-Diagramme (9Diagrammtypen)
Kompositionsstrukturdiagramm Zeitverlaufsdiagramm
Deployment-Diagramm Use Case-Diagramm
© 2017 Altova GmbH
Modell-Struktur 71UModel Benutzeroberfläche
Altova UModel 2017
Interaktionsübersichtsdiagramm XML-Schema-Diagramm
Objektdiagramm Business Process ModelingNotation
PaketdiagrammElementtypen:
Ein Element, das derzeit im aktiven Diagramm zu sehen ist, wird mit einem blauen Punkt amunteren 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 allePakete 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 öffnenDrü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 Zahlenblocksverwenden.
So suchen Sie auf dem/den Diagrammregister(n) Modellierungselemente:Beim Navigieren durch die Elemente in der Modell-Struktur möchten Sie eventuell sehen, wo oderob das Element tatsächlich in einem Modell-Diagramm vorhanden ist. Zum Suchen vonElementen stehen zwei Methoden zur Verfügung:
1. Rechtsklicken Sie auf das Element, das Sie auf dem Register "Modell-Struktur" sehenmöchten, und wählen Sie:
Element in aktivem Diagramm anzeigen - um es auf demselben Diagrammregistertypzu suchen Element in allen Diagrammen anzeigen - wenn das derzeit aktive Diagramm sich vomausgewählten Modellelement unterscheidet.
So generieren Sie eine Liste von Elementen, die in keinem Diagramm verwendet
72 UModel Benutzeroberfläche Modell-Struktur
© 2017 Altova GmbHAltova UModel 2017
werden: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ähltwurden und in der Liste der nicht verwendeten Elemente aufscheinen sollen. NähereInformationen dazu finden Sie im Referenzabschnitt unter dem Register Ansicht unterExtras | 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 Unterpaketeangezeigt.
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 werdenPakete sind die Behälter für alle anderen UML-Modellierungselemente, Use Case-Diagramme usw.Pakete/Inhalt können/kann in andere Pakete in der Modell-Struktur (und auch in gültigeModell-Diagramme auf dem Diagrammregister) verschoben/kopiert werdenPaketen und deren Inhalt können gemäß verschiedenen Kriterien sortiert werdenPakete können in andere Pakete platziert werdenPakete können beim Generieren oder Synchronisieren von Code als Quell- oderZielelemente verwendet werden
Generieren/Zusammenführen von Code:UModel gestattet Ihnen, Programmcode direkt von der Modell-Struktur aus zu generieren oderzusammenzuführen. Nähere Informationen dazu siehe: Synchronisieren von Modell- undQuellcode.
Einschränken von UML-ElementenEs 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, daEinschrä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.
© 2017 Altova GmbH
Modell-Struktur 73UModel Benutzeroberfläche
Altova UModel 2017
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 eszugewiesen wurde. In der obigen Abbildung wurde Constraint1 den Paketen bankviewund com zugewiesen.
74 UModel Benutzeroberfläche Diagramm-Struktur
© 2017 Altova GmbHAltova UModel 2017
4.2 Diagramm-Struktur
Register "Diagramm-Struktur"Auf diesem Register werden die aktuell verfügbaren UModel-Diagramme auf zwei Artendargestellt:
Gruppiert nach Diagrammtyp, in alphabetischer ReihenfolgeAls alphabetische Liste aller Projektdiagramme
Bitte beachten Sie:Diagramme können durch Rechtsklick auf das Register "Diagramm-Struktur" undAuswahl 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 anzeigenwollen.
So zeigen Sie alle Diagramme innerhalb ihrer jeweiligen Modellgruppen an:Rechtsklicken Sie in das Fenster und aktivieren Sie die Option "Diagramme nachDiagrammtyp 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 nachDiagrammtyp gruppieren".
© 2017 Altova GmbH
Diagramm-Struktur 75UModel Benutzeroberfläche
Altova UModel 2017
Alle Diagramme werden in Form einer alphabetisch sortierten Liste angezeigt.
76 UModel Benutzeroberfläche Favoriten
© 2017 Altova GmbHAltova UModel 2017
4.3 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ürProfileApplication- oder Generalisierungsbeziehungen. Auf diese Art können Sie Ihre persönlicheListe von Modellierungselementen erstellen, die zur schnellen Auswahl zur Verfügung stehen.
Der Inhalt des Registers "Favoriten" wird automatisch mit jeder Projektdatei gespeichert. Umdiese 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 einesexistierenden 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 anderesModellierungselement aus dem Kontextmenü.Neue Elemente werden zum selben Element/Paket im Projekt hinzugefügt und sind daherauch 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 überdas Register "Favoriten" als auch über das Register "Modell-Struktur" hinzufügen und
© 2017 Altova GmbH
Favoriten 77UModel Benutzeroberfläche
Altova UModel 2017
entfernen.
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 dasElement 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.
78 UModel Benutzeroberfläche Eigenschaften
© 2017 Altova GmbHAltova UModel 2017
4.4 Eigenschaften
Register EigenschaftenAuf dem Register "Eigenschaften" werden die UML-Eigenschaften des aktuell aktiven Elementsangezeigt.
Wenn Sie auf ein beliebiges Element in einer/auf einem der zur Verfügung stehendenAnsichten, Registern klicken, werden seine Eigenschaften angezeigt.Sobald die Eigenschaften angezeigt werden, können sie durch Eingabe von Daten oderAuswahl 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 ModellstrukturWenn Sie in einem Klassendiagramm auf ein Attribut klicken, werden seine Eigenschaften aufdem 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 demRegister "Eigenschaften".
2. Wählen Sie den Eintrag "In Modell-Struktur auswählen" im Kontextmenü aus.
© 2017 Altova GmbH
Eigenschaften 79UModel Benutzeroberfläche
Altova UModel 2017
Die IBankAPI-Schnittstelle wird nun in der Modell-Struktur angezeigt.
80 UModel Benutzeroberfläche Stile
© 2017 Altova GmbHAltova UModel 2017
4.5 Stile
Das Register "Stile"Auf dem Register "Stile" können Sie Attribute von Diagrammen oder Elementen, die in derDiagrammansicht 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 aufdas Listenfeld "Stile" auswählen können. Der Inhalt des Listenfelds ist vom aktuell ausgewähltenModellelement 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" wirdder Kontext "Projektstile" ausgewählt.
Die Anwendungsreihenfolge für die Stile ist von unten nach oben, d.h. Änderungen, die aufeiner spezifischeren Ebene vorgenommen wurden, setzen allgemeinere Einstellungen außerKraft. So setzen z.B. Änderungen (an einem Objekt) auf der Elementstilebene die aktuellenElementfamilie und Projektstil-Einstellungen außer Kraft. Wenn Sie jedoch ein anderes Objektauswählen und die Elementfamilie - Stile-Einstellungen ändern, werden alle anderen Objekte mitAusnahme des soeben auf der Ebene Elementstile geänderten Objekts aktualisiert.
© 2017 Altova GmbH
Stile 81UModel Benutzeroberfläche
Altova UModel 2017
Bitte beachten Sie:Alle an Modellelementen vorgenommenen Stiländerungen können rückgängig gemachtwerden!
Elementstile: Gilt für das aktuell ausgewählte Element im aktuell aktiven Diagramm. Mehrfachauswahl istmö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 alleKomponentenelemente in der Farbe "Aqua" anzeigen lassen. Daraufhin werden alle Komponentenin 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 dasgesamte Projekt.
Projektstile:Projektstile gelten für das aktuelle UModel Projekt als Ganzes (wenn Sie z.B. dieStandardschriftart "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. ihnauswählen. Wenn Sie Einstellungen hier ändern, wird davon nur das einzelne UML-Diagramm, fürdas 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 unterschiedlichenStilwerte im entsprechenden Feld angezeigt. In der Abbildung unten wurden Class1 und Class2ausgewählt.Im Feld "Füllfarbe" werden die Werte für die einzelnen Elemente angezeigt, in diesem FallAquamarin und Silber.
82 UModel Benutzeroberfläche Stile
© 2017 Altova GmbHAltova UModel 2017
Anzeige von einander überlappenden Stilen: Wenn ein Stil durch einen Stil auf einer untergeordneten Ebene außer Kraft gesetzt wird, wird aufdem Register "Stile" im entsprechenden Feld ein kleines rotes Dreieck angezeigt.Wenn Sie den Mauszeiger über das Feld platzieren, wird ein Popup-Fenster angezeigt, in demangegeben wird, welcher Stil Vorrang hat.
Beispiel:Für die Elemente "Enumeration", "Paket" und "Profil" sind in den ElementfamilienstileinstellungenStandardfüllfarben definiert. Um die Füllfarben auf Projektebene zu ändern, löschen Sie den Wertunter "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 dieFüllfarbe.
© 2017 Altova GmbH
Hierarchie 83UModel Benutzeroberfläche
Altova UModel 2017
4.6 Hierarchie
Register "Hierarchie"Auf dem Register "Hierarchie" werden alle Beziehungen des aktuell ausgewähltenModellierungselements in zwei verschiedenen Ansichten angezeigt. Das Modellierungselementkann 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 desDialogfelds 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 jeweiligenSchaltflächen durch Anklicken aktivieren. In der Abbildung oben sind alle Schaltfläche aktiv, daherwerden in einer Strukturansicht auch alle Beziehungen angezeigt.
Wenn Sie auf dem Register auf eines der Elementsymbole doppelklicken, werden dieBeziehungen dieses Elements angezeigt.
Graph. Ansicht anzeigen
84 UModel Benutzeroberfläche Hierarchie
© 2017 Altova GmbHAltova UModel 2017
In dieser Ansicht wird eine einzige Gruppe von Beziehungen in einer hierarchischen Übersichtangezeigt. Es kann immer nur jeweils eine der Beziehungsschaltflächen aktiv sein. In derAbbildung 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 angezeigtwerden.
© 2017 Altova GmbH
Hierarchie 85UModel Benutzeroberfläche
Altova UModel 2017
1. Rechtsklicken Sie in das Fenster "Graph. Ansicht" und wählen Sie den BefehlDiagramm als diesen Graph erstellen.
2. Bearbeiten Sie den Namen des Diagramms gegebenenfalls, wählen Sie die Stiloptionenaus und klicken Sie auf OK.Ein neues Diagramm wird erstellt.
86 UModel Benutzeroberfläche Übersicht - Dokumentation
© 2017 Altova GmbHAltova UModel 2017
4.7 Übersicht - Dokumentation
Register ÜbersichtAuf 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 derangezeigte Bereich auf dem Diagrammregister.
© 2017 Altova GmbH
Dokumentation 87UModel Benutzeroberfläche
Altova UModel 2017
4.8 Dokumentation
Register DokumentationÜber dieses Register können alle der auf dem Register "Modell-Struktur" verfügbaren Elementedokumentiert werden. Klicken Sie auf das gewünschte Element und geben Sie den Text auf demRegister "Dokumentation" ein. Dabei werden auch die Tastenkombinationen für dieStandardbearbeitungsbefehle "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-/Schnittstelleneigenschaftenund -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 complex- oder simpleType imFenster "Dokumentation" angezeigt.
88 UModel Benutzeroberfläche Meldungen
© 2017 Altova GmbHAltova UModel 2017
4.9 Meldungen
Im Fenster "Meldungen" werden beim Zusammenführen von Code oder beim Überprüfen derProjektsyntax Meldungen, Hinweise und Fehlermeldungen angezeigt.
Wenn Sie auf die Fehlermeldung klicken, wird das entsprechende Element in der Modell-Strukturund im dazugehörigen Diagramm markiert, falls das Diagramm gerade aktiv/offen ist.
© 2017 Altova GmbH
Diagrammfenster 89UModel Benutzeroberfläche
Altova UModel 2017
4.10 Diagrammfenster
Alle aktuell geöffneten UModel-Diagramme werden im Diagrammfenster auf einzelnen Registernangezeigt.
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 dieOption 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 Entf-Taste.
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 dasDiagramm verschieben zu können.
90 UModel Benutzeroberfläche Diagrammfenster
© 2017 Altova GmbHAltova UModel 2017
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. Dazumüssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1" in dieKlasse "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 Accountmarkiert.
3. Drücken Sie die Entf-Taste, um die Operation aus der Klasse und dem Projekt zulöschen! Beachten Sie, dass Sie durch Drücken von F4 beinahe jedes Modellierungselement in derModell-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 derBenutzerreferenz 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 aus2. 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 Diagrammvisuell strukturiert werden soll. Rechtsklicken Sie auf den Diagrammhintergrund und wählen Sieentweder:
Automatisches Layout | Zentriert oderAutomatisches Layout | HierarchischAutomatisches Layout | Block
© 2017 Altova GmbH
Diagrammfenster 91UModel Benutzeroberfläche
Altova UModel 2017
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 Optionenzur 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 undwä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.
92 UModel Benutzeroberfläche Diagrammfenster
© 2017 Altova GmbHAltova UModel 2017
2. Wählen Sie die Menüoption Anzeigen | "EigenschaftXX" als Assoziation.Daraufhin wird die referenzierte Klasse eingefügt/geöffnet und die jeweilige Assoziationwird angezeigt.
So zeigen Sie Quellcodekommentare im Modelldiagramm an:
Klicken Sie mit der rechten Maustaste in das Diagrammfenster und wählen Sie denBefehl Anzeigen | Anmerkende Kommentare.
Auf diese Art können Sie Quellcodekommentare zum Dokument (DocComments), dieauch im Fenster "Dokumentation" angezeigt werden, direkt im Modelldiagrammbearbeiten.
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.
© 2017 Altova GmbH
Diagrammfenster 93UModel Benutzeroberfläche
Altova UModel 2017
4.10.1 Diagrammeigenschaften
Konfigurieren von DiagrammeigenschaftenKlicken Sie auf den Diagrammhintergrund und wählen Sie anschließend einen der Stile aus demListenfeld "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 automatischdurch das Register zu scrollen und es zu vergrößern.
Positionieren von Modellierungselementen - das RasterModellierungselemente 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. desRahmens rund um ein Diagramm mit dem Namen in der linken oberen Ecke.
Ausrichten von ModellierungselementenModellierungselemente können in ihrer Größe und Position an anderen Elementen ausgerichtetwerden, 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 Vorlagedas zuletzt ausgewählte Element verwendet. Wenn Sie z.B. drei Klassenelemente auswählen undauf die Schaltfläche "Breite angleichen" klicken, dann werden alle drei Elemente in der Breite andie zuletzt ausgewählte Klasse angepasst.
Das gleiche gilt auch bei Markierung mehrerer Objekte mit der Marquee-Technik (Aufziehen einesRechtecks). Hier dient das zuletzt ausgewählte Element als Vorlage für die anderen markiertenObjekte
94 UModel Benutzeroberfläche Diagrammfenster
© 2017 Altova GmbHAltova UModel 2017
Schaltflächenfunktionen für die einzelnen Schaltflächengruppen:Linksbündig, RechtsbündigBündig oben, Bündig untenVertikal zentrieren, Horizontal zentrierenWaagrecht anordnen, Senkrecht anordnenHorizontal anordnen, vertikal anordnenBreite angleichen, Höhe angleichen, Größe angleichen.
Verbessertes Autokomplettierungsfenster - Auswählen von DatentypenWenn Sie Datentypen für Operationen oder Eigenschaften eingeben, wird automatisch einAutokomplettierungsfenster angezeigt, das die folgenden Funktionen aufweist:
Bei Klick auf einen Spaltennamen wird das Fenster in aufsteigender/absteigenderReihenfolge 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 entsprechendeKategoriesymbol am unteren Rand des Fensters filtern.
Mit der Schaltfläche Einzelmodus können Sie wechseln zwischen der Aktivierungnur eines der Kategoriesymbole auf einmal (Einzelmodus) oder der Aktivierung mehrererKategoriesymbole (Mehrfachmodus). In der Abbildung unten sehen Sie dasAutokomplettierungsfenster im Mehrfachmodus, d.h. alle Kategoriesymbole sind aktiviert.Das Einzelmodussymbol ist deaktiviert.Mit den Schaltflächen "Alle setzen / Zurücksetzen" können Sie alleKategorieeinstellungen setzen bzw. zurücksetzen.Wenn die Autokomplettierung deaktiviert ist, drücken Sie Strg+ Leerzeichen, um dasAutokomplettierungsfenster 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 "AutomatischeEingabehilfe aktivieren". Diese Einstellung hat keinen Einfluss auf die Funktion zumAufrufen des Autokomplettierungsfensters.
© 2017 Altova GmbH
Diagrammfenster 95UModel Benutzeroberfläche
Altova UModel 2017
4.10.2 Ausschneiden, Kopieren und Einfügen in UModel Diagramme
Ausschneiden, Kopieren und Einfügen von Diagrammelementen im DiagrammfensterAlle UModel Diagrammelemente können innerhalb desselben Typs, zwischen verschiedenenTypen 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 demKontextmenübefehl "Einfügen" oder über den Befehl "Einfügen" aus dem Menü"Bearbeiten". Dabei wird immer ein neues Modellelement zum Diagramm und zurModell-Struktur hinzugefügt.
Mit dem Kontextmenübefehl "Nur in Diagramm einfügen" (aufrufbar durch Rechtsklickauf den Diagrammhintergrund) wird ein "Link/eine Ansicht" des bestehenden Elementszum 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 eineneue Klasse mit dem Quellklassennamen plus einer Sequenznummer eingefügt. Solautet der Name der Quellklasse z.B. myClass. Eingefügt wird der KlassennamemyClass1. Alle Operationen und Eigenschaften werden auch in die neue Klasse kopiert.
Durch Einfügen einer kopierten Klasse in ein anderes Paket wird ebenfalls eine neueKlasse eingefügt, doch wird der ursprüngliche Klassenname beibehalten. In beiden Fällenwird 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 mitdem Namen der Quelleigenschaft sowie einer Sequenznummer eingefügt, also z.B.MyProperty1.
Durch Einfügen einer Operation in dieselbe Klasse wird eine neue Operation mitdemselben Namen der Quelloperation eingefügt.
96 UModel Benutzeroberfläche Diagrammfenster
© 2017 Altova GmbHAltova UModel 2017
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 Elementeinfügen ein "Link" zum bzw. eine "Ansicht" des Elements erstellt. Hier ein Beispiel aus demKlassendiagramm:
Mit dem Befehl "Nur in Diagramm einfügen" wird eine Ansicht der Ursprungsklasseerstellt.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/Eigenschaftenvorgenommen.Wenn Sie die Eigenschaften des Elements in einer der "Ansichten" ändern, werden dieseauch 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 Kopiervorganghandelt.
4. Lassen Sie die Maustaste los.
© 2017 Altova GmbH
Diagrammfenster 97UModel Benutzeroberfläche
Altova UModel 2017
Es erscheint ein Popup-Menü, aus dem Sie einen der Befehle "Einfügen" oder "Nur inDiagramm 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 direktinnerhalb einer Klasse kopieren oder verschieben.
98 UModel Benutzeroberfläche Hinzufügen/Einfügen von Modellelementen
© 2017 Altova GmbHAltova UModel 2017
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 dasDiagrammregisterDurch Klicken auf ein bestimmtes UML-Elementsymbol und Einfügen in das DiagrammDurch Verwenden das Kontextmenüs, um Elemente zum Diagramm (und automatischzur Modell-Strukturansicht) hinzuzufügen.
Bitte beachten Sie, dass mehrere Elemente in der Modell-Strukturansicht entweder durchUmschalt + 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 zumarkieren, halten Sie die Strg-Taste gedrückt und klicken Sie auf die einzelnen Elemente. ZumEinfügen der Elemente in das Diagramm stehen zwei verschiedene Methoden zur Verfügung: linksziehen 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 denaktuell eingefügten und dem neuen Element bestehen, angezeigt).
Rechts ziehen (halten Sie die rechte Maustaste gedrückt und lassen Sie sie auf demDiagrammregister 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.
© 2017 Altova GmbH
Hinzufügen/Einfügen von Modellelementen 99UModel Benutzeroberfläche
Altova UModel 2017
3. Wählen Sie den Eintrag Einfügen mit Generalisierungshierarchie (spezifisch).
4. Deaktivieren Sie die Kontrollkästchen für die Elemente, die in den Elementen angezeigtwerden sollen (in diesem Fall für Eigenschaften und Operationen).
5. Klicken Sie auf OK.Die Klasse "Account" und ihre drei Unterklassen werden alle auf demDiagrammregister eingefügt. Die Generalisierungspfeile werden automatisch angezeigt.
Hinzufügen von Elementen zu einem Diagramm mittels der Symbole in derSymbolleiste:
1. Wählen Sie das jeweilige Element, das Sie einfügen möchten aus, indem Sie in derSymbolleiste 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 desselbenTyps 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 Elementautomatisch zum Register "Modell-Struktur" hinzugefügt. Das Element wird zu demPaket hinzugefügt, das in der Modell-Strukturansicht das UML-Diagramm enthält.
Rechtsklicken Sie auf ein Element und wählen Sie Anzeigen | xxWenn Sie z.B. auf die Klasse "Account" rechtsklicken und den Eintrag Anzeigen |Generalisierungshierarchie wählen, werden die abgeleiteten Klassen ebenfalls in dasDiagramm eingefügt.
100 UModel Benutzeroberfläche Verknüpfen von Modellierungselementen
© 2017 Altova GmbHAltova UModel 2017
4.12 Verknüpfen von Modellierungselementen
UModel unterstützt nun das automatische und manuelle Verknüpfen von Modellierungselementenmittels Hyperlink. Die Hyperlinks werden automatisch erstellt, wenn Sie beim Importieren vonQuellcode 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-Projektjedem Element in einem Diagrammjedem Element in der Modellstrukturexternen Dokumenten, z.B. PDF-, Excel- oder Word-DokumentenWebseiten
unterstützt.
Anmerkung:Alle manuell erstellten Hyperlinks stehen bei Generierung von UML-Dokumentation auchin der HTML-Projektdokumentation zur Verfügung.
Wenn Sie das Bank Server-Diagramm unter dem Paket "Bank Server" öffnen, wird die IBankAPI-Schnittstelle sowie die BankServer-Klasse angezeigt. Auch ein Enumerationselement, das dieNamen der EnumerationLiterals enthält, ist zu sehen. Wir möchten nun einen Hyperlink vonEnumeration 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.
© 2017 Altova GmbH
Verknüpfen von Modellierungselementen 101UModel Benutzeroberfläche
Altova UModel 2017
Daraufhin wird das Dialogfeld "Hyperlinks bearbeiten" geöffnet. Hier werden die Hyperlinksverwaltet.
2. Klicken Sie auf die Schaltfläche hinzufügen, und wählen Sie die Option Diagramm-Link, 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 ofAccount diagram, und klicken Sie auf OK.
Wenn Sie in die Spalte "benutzerdefinierter Name" doppelklicken, können Sie Ihreneigenen Link-Namen definieren.Beachten Sie: Sie können mehrere und auch verschiedene Arten von Links von einemeinzigen 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.htmlhinzufügen.
102 UModel Benutzeroberfläche Verknüpfen von Modellierungselementen
© 2017 Altova GmbHAltova UModel 2017
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 Sieden Mauscursor über das Link-Symbol platzieren, erscheint ein Popup mit dem Namendes 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.
© 2017 Altova GmbH
Verknüpfen von Modellierungselementen 103UModel Benutzeroberfläche
Altova UModel 2017
2. Wählen Sie das jeweilige Modellierungselement, zu dem Sie einen Link erstellenmöchten, und klicken Sie auf OK.
Wenn Sie auf das Link-Symbol klicken, wird das jeweilige Diagramm geöffnet, wobei dasElement 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 Elementgeführt, das Sie im Dialogfeld in der Modell-Struktur ausgewählt haben.
Anmerkung: Beim Generieren von Projektdokumentation werden die Hyperlinks zu denModellelementen in der Modell-Struktur angepasst, sodass sie in der generiertenDokumentation 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.
104 UModel Benutzeroberfläche Verknüpfen von Modellierungselementen
© 2017 Altova GmbHAltova UModel 2017
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 einesder verfügbaren Ziele auswählen können.
Wenn Sie auf den ersten Eintrag klicken, wird das Hierarchy of Account-Diagrammgeöffnet.
Navigieren von Hyperlinks:
Klicken Sie in der Hauptsymbolleiste auf die Symbole "Vorheriges" und
"Nächstes" 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.
© 2017 Altova GmbH
Verknüpfen von Modellierungselementen 105UModel Benutzeroberfläche
Altova UModel 2017
106 UModel Benutzeroberfläche Bank-Beispieldateien
© 2017 Altova GmbHAltova UModel 2017
4.13 Bank-Beispieldateien
Der Ordner ...\UModelExamples enthält Dateien mit Beispielen zu verschiedenen Aspekten derUML-Modellierung in UModel. Sie sind so ausgelegt, dass Modelle für die ProgrammiersprachenJava und C# sowie eine Kombination beider Sprachen in einem Modellierungsprojekt zu sehensind.
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 einSequenzdiagramm 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.das Paket "Interaction View" enthält zwei Interaction-Elemente, von denen jedes einSequenzdiagramm enthält.
© 2017 Altova GmbH
Bank-Beispieldateien 107UModel Benutzeroberfläche
Altova UModel 2017
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 Paket "Interaction View" enthält zwei Interaction-Elemente, von denen jedes einSequenzdiagramm enthält.das Projekt wurde in 4 editierbare Unterprojekte, nämlich Bank Server.ump, Bankingaccess.ump, BankView.ump und Bank_Multilanguage_Use Case View.ump aufgeteilt.
Kapitel 5
UModel Befehlszeilenschnittstelle
110 UModel Befehlszeilenschnittstelle
© 2017 Altova GmbHAltova UModel 2017
5 UModel Befehlszeilenschnittstelle
Zusätzlich zur grafischen Benutzeroberfläche verfügt UModel auch über eineBefehlszeilenschnittstelle. Um die Befehlszeilenschnittstelle aufzurufen, führen Sie die Datei UModelBatch.exe aus dem Ordner C:\Programme\Altova\UModel2017 aus. Wenn Sie dieUModel 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 Befehlseingabeangezeigt werden, wenn Sie eingeben: umodelbatch /?
Hinweis: Wenn der Pfad oder Dateiname Leerzeichen enthält, setzen Sie den Pfad/Dateinamenbitte in Anführungszeichen, d.h. "c:\Programme\...\Dateiname"
usage: umodelbatch [project] [options]
/? oder /help ... diese Hilfeinformationen anzeigen
Projekt ... Projektdatei (*.ump) siehe auch Datei: New/Load/Save-Optionen/new[=Datei]... neues Projekt erstellen/speichern/unter einem neuen Namenspeichern /set ... Optionen permanent festlegen/gui ... 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,*.bdsproj)/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 verwendetwerden (d.h. nicht verwendete)/ldg ... alle Diagramme auflisten/lcl ... alle Klassen auflisten/lsp ... alle freigegebenen Pakete auflisten/lip ... alle inkludierten Pakete auflisten
© 2017 Altova GmbH
111UModel Befehlszeilenschnittstelle
Altova UModel 2017
Optionen zum Speichern als neues Projekt:/npad=opt ... 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 | C#7.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-Bibliothekenauß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
112 UModel Befehlszeilenschnittstelle
© 2017 Altova GmbHAltova UModel 2017
Optionen für den XMI-Export:/exid[=0|1] ... UUIDs exportieren/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). Siekönnen diesen Parameter auch verwenden, um ein bestehendes Projekt unter einemanderen 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 derRegistrierungsdatei, wobei die Optionen/Einstellungen hier definiert werden.
Der Parameter /gui zeigt die UModel-Benutzeroberfläche bei der Batchverarbeitung an.
Beispiel 1Der folgende Befehl importiert Quellcode und erstellt eine neue Projektdatei. Beachten Sie, dassder 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 undunter C:\Program Files\Altova\U M odel2017\UModelBatchOut\ erstellt werdensoll
/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 derRegistrierungsdatei gespeichert werden sollen (Wenn UModel anschließendgestartet 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-Verzeichnissesrekursiv 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
© 2017 Altova GmbH
113UModel Befehlszeilenschnittstelle
Altova UModel 2017
/dopn=1: generierte Diagramme öffnen
/dmax=5: maximal fünf Diagramme öffnen
/chk: Syntaxüberprüfung durchführen
Beispiel 2Der folgende Befehl importiert Quellcode aus X:\TestCases\UModel und speichert die erzeugteProjektdatei 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 3Der 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
114 UModel Befehlszeilenschnittstelle Datei: New / Load / Save-Optionen
© 2017 Altova GmbHAltova UModel 2017
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 vonden 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) /newLä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.umpLä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 Parameterwird verwendet.
new UModelBatch /gui /new (options)Erstellt ein neues Projekt, führt die Optionen aus, nichts wird gespeichert, die GUI bleibtoffen
save new UModelBatch /gui /new=xxx.ump (options)Erstellt ein neues Projekt, führt die Optionen aus, xxx.ump wird gespeichert, die GUIbleibt offen
user modeUModelBatch /gui xxx.ump (options)Lädt das Projekt xxx.ump, führt die Optionen aus, nichts wird gespeichert, die GUI bleibtoffen
save UModelBatch /gui xxx.ump (options) /new Lädt das Projekt xxx.ump, führt die Optionen aus, xxx.ump wird gespeichert, die GUIbleibt 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, dieGUI bleibt offen
© 2017 Altova GmbH
Datei: New / Load / Save-Optionen 115UModel Befehlszeilenschnittstelle
Altova UModel 2017
Das Projekt wird erfolgreich gespeichert, wenn bei Ausführung der Optionen keinschwerwiegender Fehler auftritt.
Kapitel 6
Projekte und Code Engineering
118 Projekte und Code Engineering
© 2017 Altova GmbHAltova UModel 2017
6 Projekte und Code Engineering
Alle Java-spezifischen Konstrukte werden nun in UModel unterstützt, unteranderem:
Java AnnotationenAttribute, Operationen und geschachtelte Qualifier für EnumerationLiteralsEnumerationen können Schnittstellen realisierenNetBeans Projektdateien
Reverse Engineering unterstützt jetzt:die Möglichkeit ein einziges Diagramm für alle mit Reverse Engineering generiertenElemente zu erzeugen. die Möglichkeit, anonyme gebundene Elemente in Diagrammen ein- und auszublendendie Möglichkeit, während des Imports automatisch Hyperlinks von Paketen zu denentsprechenden Paket-Inhaltsdiagrammen anzulegen.die Möglichkeit Aliasse aufzulösen.das Schreiben von Unicode-Zeichen in neue Quellcodedateiendas 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 demStandardnamen NeuesProjekt1 erstellt. Beachten Sie, dass beim Start von UModel automatischein neues Projekt geöffnet wird.
Ein neu erstelltes UModel-Projekt besteht aus den folgenden Paketen:
Root-Paket undComponent View-PaketDiese beiden Pakete sind die einzigen, die nicht umbenannt oder gelöscht werdenkönnen.
© 2017 Altova GmbH
119Projekte und Code Engineering
Altova UModel 2017
Alle projektrelevanten Daten werden in der UModel-Projektdatei gespeichert. Diese Datei hat dieErweiterung *.ump. Jedes Ordnersymbol auf dem Register "Modell-Struktur" stellt ein UML-Paketdar!
UModel-Projektarbeitsablauf:UModel zwingt Sie nicht, sich bei der Modellierung an eine bestimmte vordefinierte Reihenfolge zuhalten!
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, dassalle Modellelemente direkt auf dem Register "Modell-Struktur" eingefügt, umbenannt und gelöschtwerden können, d.h. Sie müssen diese Elemente nicht unbedingt als Teil eines Diagrammserstellen.
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 wirdautomatisch markiert, sodass Sie sofort den Paketnamen eingeben können.
Pakete sind die Behälter für alle anderen UML-Modellierungselemente, Use Case-Diagramme, 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ültigeModell-Diagramme auf dem Diagrammregister) verschoben/kopiert werden.Pakete und deren Inhalt können (auf dem Register "Modell-Struktur") nach verschiedenenKriterien sortiert werden.Pakete können innerhalb von anderen Paketen platziert werden.Pakete können beim Zusammenführen oder Synchronisieren von Code als Quell- oderZielelemente 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 oder3. 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 beimSpeichern 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 vorgenommenwurden, werden automatisch erkannt und es erscheint eine entsprechende Meldung. Siekönnen auswählen, ob das Projekt neu geladen werden soll oder nicht.
So verschieben Sie ein Projekt:
120 Projekte und Code Engineering
© 2017 Altova GmbHAltova UModel 2017
UModel-Projekte und generierter Code können ganz einfach in ein anderes Verzeichnis (oder aufeinen 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 Siegefragt werden, ob die Dateipfade an den neuen Projektordner angepasst werden sollen.
Kopieren Sie das UModel-Projekt (*.ump) in einen neuen Ordner und passen Sie diePfade der Codegenerierungspakete in der Komponentendiagrammansicht an das neueVerzeichnis 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.
© 2017 Altova GmbH
Mini-UModel Projekt - von Grund auf neu erstellen 121Projekte und Code Engineering
Altova UModel 2017
6.1 Mini-UModel Projekt - von Grund auf neu erstellen
In diesem Abschnitt werden die Schritte beschrieben, die nötig sind, um ein Projekt von Grund aufneu zu erstellen und Code für eine einzige Klasse zu generieren. Hier wird anhand eines Mini-Projekts jedoch unter Verwendung mehrerer Diagramme gezeigt, wie man Methoden hinzufügtusw. Alle diese Aktionen könnten auch nur unter Verwendung des Registers "Modell-Struktur"durchgeführt werden. Zur Erstellung von Klassen oder Methoden werden keineModellierungsdiagramme benötigt.
Erstellen eines neuen Projekts und Definieren der Namespace RootFü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 JavaNamespace Root definieren und klicken Sie auf OK, um das UModel Java Profil aufdas Paket anzuwenden.Daraufhin wird ein Java-Profilpaket zur Modell-Struktur hinzugefügt.
Inkludieren von Java Lang für JDK-Datentypen1. 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 Modell-Struktur hinzugefügt.
Erstellen der Klasseneigenschaften und Methoden1. Rechtsklicken Sie auf MyPackage und wählen Sie die Option Neues Diagramm |
122 Projekte und Code Engineering Mini-UModel Projekt - von Grund auf neu erstellen
© 2017 Altova GmbHAltova UModel 2017
Klassendiagramm.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-Verzeichnisses1. 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.
© 2017 Altova GmbH
Mini-UModel Projekt - von Grund auf neu erstellen 123Projekte und Code Engineering
Altova UModel 2017
3. Fügen Sie eine neue Komponente zum Diagramm hinzu z.B. MyComponent.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 dasVerzeichnis ein, in dem der Code gespeichert werden soll, z.B. C:\MyCode.
Realisieren der Klasse1. Klicken Sie auf MyFirstClass und ziehen Sie den Ziehpunkt
"Komponentenrealisierung" am unteren Rand des Elements auf die neue KomponenteMyComponent.
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 ziehenkönnten.
Syntaxüberprüfung und Generierung von Code1. Wählen Sie die Option Projekt | Projektsyntax überprüfen, um zu überprüfen, ob alles
124 Projekte und Code Engineering Mini-UModel Projekt - von Grund auf neu erstellen
© 2017 Altova GmbHAltova UModel 2017
in Ordnung ist.
Es werden null Fehler und eine Warnung generiert. Obwohl der Codename vorher nichtdefiniert wurde, wird automatisch ein Standardname generiert.
2. Wählen Sie Projekt | Merge Programmcode aus UModel-Projekt um Java-Codeauszugeben/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".
© 2017 Altova GmbH
Mini-UModel Projekt - von Grund auf neu erstellen 125Projekte und Code Engineering
Altova UModel 2017
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.
126 Projekte und Code Engineering Importieren von Quellcode in Projekte
© 2017 Altova GmbHAltova UModel 2017
6.2 Importieren von Quellcode in Projekte
Quellcode kann als Quellprojekt oder als Quellverzeichnis importiert werden. Ein Beispiel dazufinden Sie im Tutorial unter Round-Trip Engineering (Code - Modell - Code).
JBuilder .jpx, Eclipse .project Projektdateien sowie NetBeans (project.xml) werdenderzeit unterstützt.. C#-Projekte / Visual Basic-Projekte (Visual Studio- sln, csproj, csdprj..., vbproj, vbpsowie 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 findendie diese JBuilder-Projektdatei in der Datei OrgChart.zip im Ordner ...\UModelExamples.Beachten Sie, dass die Option zum Importieren des Projekts relativ zur UModel-Projektdatei aktiv ist. Damit UModel Klassen- und Paketdiagramme generiert, aktivierenSie das Kontrollkästchen "Diagrammgenerierung aktivieren" und klicken Sieanschließend auf "Weiter".
4. Aktivieren Sie das Kontrollkästchen "In neues Paket importieren" (oder klicken Sie imFester "Importziel" auf das entsprechende Paket).
© 2017 Altova GmbH
Importieren von Quellcode in Projekte 127Projekte und Code Engineering
Altova UModel 2017
5. Wenn Sie dazu aufgefordert werden, aktivieren Sie die Optionen Einzelnes Diagrammgenerieren und/oder Diagramm pro Paket generieren. Die Stile für das Diagrammkö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 vonPaketabhängigkeiten definieren.
128 Projekte und Code Engineering Importieren von Quellcode in Projekte
© 2017 Altova GmbHAltova UModel 2017
7. Klicken Sie auf "Fertig stellen", um die Standardeinstellungen zu verwenden. Das Projektwird geparst und das UModel-Modell wird generiert.
Bitte beachten Sie:
© 2017 Altova GmbH
Importieren von Quellcode in Projekte 129Projekte und Code Engineering
Altova UModel 2017
Beim Import in ein bestehendes Projekt werden Sie gefragt, in welches Paket esimportiert 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 Sienun auswählen, ob der Alias aufgelöst werden soll (Kontrollkästchen "Aliasse auflösen" imDialogfeld "Quellprojekt/Verzeichnis importieren").
Wenn Code aktualisiert wird, d.h. wenn Code anhand des Modells aktualisiert wird, werden Alias-Definitionen im Code unverändert beibehalten. Der Geltungsbereich der Aliasdefinitionen sind dieDateien, 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 "unbekanntenexternen Elementen" hinzugefügt, wenn ihre Verwendung nicht eindeutig ist.
Anmerkung:Die Einstellung "Aliasnamen auflösen" kann jederzeit im Dialogfeld "Projekteinstellungen"geändert werden.
Definierte SymboleIn C#- oder Visual Basic-Code können Sie eine Liste von "definierten Symbolen" in dasgleichnamige Feld eingeben. Mit Hilfe dieser Anweisungen können Sie Codeabschnitte beiZutreffen bestimmter Bedingungen kompilieren. Geben Sie diese Anweisungen in Form einerdurch 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 dasReverse Engineering abgeschlossen ist.
Z.B. #If DEBUG ThenDim i = 10#Elsedim a = 20#End If
AusnahmeereignisseWenn Sie in einer der Klassen auf eine Operation klicken und anschließend auf dasDropdown-Listenfeld Exception werden die Informationen zum Ausnahmeereignisangezeigt, das eine Operation auslösen kann.
130 Projekte und Code Engineering Importieren von Quellcode in Projekte
© 2017 Altova GmbHAltova UModel 2017
© 2017 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 131Projekte und Code Engineering
Altova UModel 2017
6.3 Importieren von Java-, C#- und VB-Binärdateien
UModel unterstützt den Import von C#-, Java- und VB-Binärdateien. Diese Funktion erweist sichvor allem beim Arbeiten mit Binärdateien aus externen Quellen oder, wenn der Quellcode nichtmehr zur Verfügung steht, als besonders nützlich.
Um Java-Binärdateien zu importieren, müssen Java Runtime Environment (JRE) oder DevelopmentKit (JDK) Version 1.4, 1.5, 1.6, 1.7, 1.8 installiert sein. Der Import von Typen wird für ClassArchives unterstützt, die für diese Umgebungen vorgesehen sind, d.h. die den Java VirtualMachine Spezifikationen entsprechen.
Um C#- oder VB-Binärdateien zu importieren, muss das .NET Framework installiert sein. DerImport von Typen wird für Assemblies unterstützt, die für folgende Umgebungen vorgesehensind: .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, wirdnicht unterstützt.
So importieren Sie Binärdateien:
1. Wählen Sie die Menüoption Projekt | Binärtypen importieren.
132 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2017 Altova GmbHAltova UModel 2017
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).
© 2017 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 133Projekte und Code Engineering
Altova UModel 2017
4. Klicken Sie auf das "+" Erweiterungssymbol, um die Liste der Binärdateien zu erweiternund aktivieren Sie das/die Kontrollkästchen jener Datei(en), die Sie importieren möchten.
8. Klicken Sie auf "Weiter". Daraufhin wird das Dialogfeld Optionen für den Import vonBinärdateien.
134 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2017 Altova GmbHAltova UModel 2017
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".
© 2017 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 135Projekte und Code Engineering
Altova UModel 2017
11. Wählen Sie im Dialogfeld die Eigenschaften für die Generierung eines Inhaltsdiagrammsaus 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.
136 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2017 Altova GmbHAltova UModel 2017
12. Wählen Sie die gewünschten Paketabhängigkeitsoptionen aus und klicken Sie auf "Fertigstellen", um den Importvorgang fertig zu stellen. In der Abbildung unten sehen Sie dasDiagramm, das die Paketabhängigkeiten der Java-Binärdateien enthält.
Anmerkung: Wenn Sie auf das Link-Symbol eines Ordners klicken, wird das referenzierteDiagramm automatisch geöffnet.
© 2017 Altova GmbH
Synchronisieren von Modell und Quellcode 137Projekte und Code Engineering
Altova UModel 2017
6.4 Synchronisieren von Modell und Quellcode
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-inausgeführt wird, erfolgt die Synchronisierung zwischen Modell und Codeautomatisch. Eine manuelle Synchronisierung ist auf Projektebene möglich; dieOption 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 zumZusammenfü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 eineKlasse usw.
Je nachdem, welche Einstellungen Sie unter Projekt | Synchronisierungseinstellungendefiniert 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) zuaktualisieren, können Sie auch die beiden folgenden Befehle aus dem Projekt-Menü von UModelverwenden:
Merge (oder Überschreibe) Programmcode aus UModel ProjektMerge (oder Überschreibe) UModel Projekt aus Programmcode
Aus Gründen der Einfachheit werden die oben aufgelisteten Befehle in diesem Kapitel allgemeinals Codesynchronisierungsbefehle bezeichnet.
Wählen Sie eine der folgenden Methoden, um eine Synchronisierung auf Projekt- oderRoot-Paketebene durchzuführen:
Klicken Sie mit der rechten Maustaste auf das Root-Paket in der Modell-Struktur undwä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)
138 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2017 Altova GmbHAltova UModel 2017
auszuwählen2. Klicken Sie mit der rechten Maustaste auf die Auswahl und wählen Sie den gewünschten
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ünschtenCodesynchronisierungsbefehl aus.
Um beim Synchronisieren von Modell und Code unerwünschte Ergebnisse zu vermeiden,betrachten Sie bitte die folgenden Szenarien:
Auswahl des Befehls ÜberschreibeUModel Projekt ausProgrammcode im Menü Projekt
Dabei werden alle Verzeichnisse (Projektdateien)aller verschiedenen von Ihnen in Ihrem Projektdefinierten Codesprachen überprüft.Neue Dateien werden ermittelt und zum Projekthinzugefügt.In Ihrem Meldungsfenster erscheint der Eintrag"Quelldateien werden in 'C:\UMTest' gesammelt".
Rechtsklick auf eine Klasse oderSchnittstelle in der Modell-Struktur undAuswahl von Code Engineering |Überschreibe UModel Klasse vonProgrammcode
Daraufhin wird nur die ausgewählte Klasse(Schnittstelle,...) Ihres Projekts aktualisiert.Wenn der Quellcode jedoch neue oder seit derletzten Synchronisierung geänderte Klassenenthält, werden diese Änderungen nicht zum Modellhinzugefügt.
Rechtsklick auf eine Komponente inder Modell-Struktur (im ComponentView-Paket) und Auswahl von CodeEngineering | Überschreibe UModelKomponente 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 demSie aufgefordert werden, Ihr UModel-Projekt vor dem Synchronisieren zu aktualisieren.Dies kommt nur bei UModel-Projekten vor, die mit einer Vorversion der letzten Releaseerstellt wurden. Klicken Sie bitte auf JA um Ihr Projekt zu aktualisieren und IhreProjektdatei zu speichern. Anschließend wird diese Aufforderung nicht mehr angezeigt.
Synchronisierungseinstellungen
Sie können die Synchronisierungsoptionen über den Menübefehl Projekt |Synchronisierungsoptionen ändern.
© 2017 Altova GmbH
Synchronisieren von Modell und Quellcode 139Projekte und Code Engineering
Altova UModel 2017
SPL-Vorlagen
SPL-Vorlagen werden bei der Generierung von Java-, C#- und VB.NET-Code verwendet. SPL-Vorlagen werden nur verwendet/aufgerufen, wenn neuer Code generiert wird, d.h. wenn neuerCode 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 übergeordneteVerzeichnis, 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".
6.4.1 Tipps zur Synchronisierung
Umbenennen von Classifiern und Reverse Engineering
Der unten beschriebenen Vorgang beim Reverse Engineering oder der automatischen
140 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2017 Altova GmbHAltova UModel 2017
Synchronisierung bezieht sich sowohl auf die Standalone-Applikation als auch auf die Plug-In-Versionen (Visual Studio oder Eclipse).
Wenn Sie einen Classifier im Code-Fenster Ihrer Programmierapplikation umbenennen, wird ergelöscht und als neuer Classifier in die Modell-Struktur eingefügt.
Der neue Classifier wird nur in diejenigen Modellierungsdiagramme eingefügt, die beim ReverseEngineering automatisch erstellt werden, oder wenn ein Diagramm mit dem Befehl In neuemDiagramm anzeigen | Inhalt erstellt wird. Der neue Classifier wird an der Standardposition imDiagramm eingefügt. Diese ist wahrscheinlich nicht mit der vorherigen Position identisch.
Siehe auch Refactoring und Synchronisierung von Code.
Automatische Generierung von KomponentenrealisierungenUModel kann in Rahmen der Codegenerierung automatisch Komponentenrealisierungengenerieren. Komponentenrealisierungen werden nur generiert, wenn es absolut klar ist, welcherKomponente 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 strenggetrennt.
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 (undnur eine) Komponente zugewiesen werden kann.
ohne Komponentenrealisierung odereine 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/realisiertwenn es EINE Komponente gibt, die Classifier in einem Unterpaket, des Pakets, das sieenthä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)
Komponente, die ein Verzeichnis repräsentiert (Eigenschaft "directory" ist aktiviert)wenn es EINE Komponente gibt, die Classifier im Paket, das sie enthält, hat/realisiertwenn es EINE Komponente gibt, die Classifier in einem der übergeordneten Pakete hat/realisiert (von unten nach oben)
© 2017 Altova GmbH
Synchronisieren von Modell und Quellcode 141Projekte und Code Engineering
Altova UModel 2017
Anmerkungen:Die Option "Code Engineering | Fehlende Komponentenrealisierungengenerierten" muss aktiviert sein.Sobald bei einem der obigen Schritte EINE verwendbare Komponente gefunden wird, wirddiese 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 Fehlermeldunggeneriert (Meldungsprotokoll)
6.4.2 Refactoring und Synchronisierung von Code
Beim Refactoring von Code müssen oft Klassennamen geändert/aktualisiert werden. In Versionenvor UModel 2009 wurden bei der Synchronisierung von Code die "alten" Klassen gelöscht undneue eingefügt.
Falls in UModel ab Version 2009 beim Reverse Engineering festgestellt wird, dass neue Typenhinzugekommen/umbenannt worden sind, wird nun ein Dialogfeld geöffnet. Die neuen Typenwerden in der Spalte "Name im Code" geöffnet, während der vom Programm als ursprünglicherTypname angenommene Name in der Spalte "Name im Modell" aufgelistet wird. UModel ermitteltden Originalnamen anhand vonn Namespace, Klasseninhalt, Basisklassen und anderen Daten.
Wenn eine Klasse umbenannt wurde, wählen Sie den früheren Klassennamen über dieAuswahlliste in der Spalte "Name im Modell" aus, z.B. C1. Damit stellen Sie sicher, dass alledamit in Zusammenhang stehenden Daten beibehalten werden und das Code Engineering korrekterfolgt.
142 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2017 Altova GmbHAltova UModel 2017
Ändern von Klassennamen im Modell und Neugenerierung von CodeWenn Sie ein Modell erstellt haben und anhand dieses Modells Code generiert haben, möchtenSie unter Umständen nochmals Änderungen am Modell vornehmen, bevor Sie dieSynchronisierung vornehmen.
Beispiel: Sie haben beschlossen, Klassennamen zu ändern, bevor Sie Code zum zweiten Malgenerieren. Da Sie jeder Klasse zuvor einen Dateinamen zugewiesen haben, würde der neueName der Klasse und der Datei nun im Fenster "Eigenschaften" im Feld "Codedateiname" nichtmehr übereinstimmen.
UModel fragt Sie, ob der Name der Codedatei an den neuen Namen der Klasse angepasst werdensoll, bevor Sie die Synchronisierung starten. Beachten Sie, dass Sie auch die Möglichkeit haben,auch die Klassenkonstruktoren zu ändern.
Round-Trip Engineering und Beziehungen zwischen Modellelementen:
Beim Aktualisieren des Modells anhand von Code werden Assoziationen zwischenModellelementen automatisch angezeigt, wenn die Option Bearbeiten | Assoziationenautomatisch erstellen im Dialogfeld Extras | Optionen aktiviert wurde. Assoziationen werden fürjene Elemente angezeigt, bei denen der Attributtyp definiert ist und bei denen sich dasreferenzierte "Typ"-Modellelement im selben Diagramm befindet.
Die Schnittstellenrealisierungen sowie die Generalisierungen werden beim Aktualisieren desModells anhand von Code automatisch angezeigt.
© 2017 Altova GmbH
Voraussetzungen für Forward Engineering 143Projekte und Code Engineering
Altova UModel 2017
6.5 Voraussetzungen für Forward Engineering
Mindestvoraussetzungen für das Erzeugen von Code für das Forward Engineering:
Eine Komponente muss durch eine oder mehrere Klassen oder Schnittstellenrealisiert werden.Die Komponente muss einen physischen Pfad haben, d.h. es muss ihr ein Verzeichniszugewiesen sein. Der generierte Code wird anschließend in diesem Verzeichnisabgelegt. 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 Modell-
Strukturansicht.
Sie können auch über das Symbol "Realisierung" in einem Komponentendiagramm eineRealisierung erstellen.
So weisen Sie einen physischen Ordner zu:1. Wählen Sie die Komponente in der Modell-Struktur oder im Diagramm aus.
2. Klicken Sie auf die Durchsuchen-Schaltfläche der Eigenschaft Verzeichnis undwählen Sie ein Verzeichnis aus (oder geben Sie es direkt ein).
So inkludieren Sie Komponenten in den Code Engineering-Vorgang:
144 Projekte und Code Engineering Voraussetzungen für Forward Engineering
© 2017 Altova GmbHAltova UModel 2017
1. Wählen Sie die Komponente in der Modell-Struktur oder im Diagramm aus.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 Engineering-Vorgangs 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.
© 2017 Altova GmbH
Generieren von Java-Code aus UModel-Elementen und umgekehrt 145Projekte und Code Engineering
Altova UModel 2017
6.6 Generieren von Java-Code aus UModel-Elementen undumgekehrt
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 demModell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER um dieHTML-Version der Tabelle in Ihrem Browser zu öffnen.
146 Projekte und Code Engineering Generieren von C#-Code aus UModel Elementen und umgekehrt
© 2017 Altova GmbHAltova UModel 2017
6.7 Generieren von C#-Code aus UModel Elementen undumgekehrt
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
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER um dieHTML-Version der Tabelle in Ihrem Browser zu öffnen.
© 2017 Altova GmbH
XML Schema von/zu UModel Elementen 147Projekte und Code Engineering
Altova UModel 2017
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 insModell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER um dieHTML-Version der Tabelle in Ihrem Browser zu öffnen.
148 Projekte und Code Engineering Konvertierung VB.NET-Code - UModel-Elemente
© 2017 Altova GmbHAltova UModel 2017
6.9 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 CodeVB.NET-Code-Elementen und UModel-Modellelementen bei der Eingabe von Code in dasModell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER um dieHTML-Version der Tabelle in Ihrem Browser zu öffnen.
© 2017 Altova GmbH
Inkludieren anderer UModel-Projekte 149Projekte und Code Engineering
Altova UModel 2017
6.10 Inkludieren anderer UModel-Projekte
Um ein UModel-Projekt als Unterprojekt eines anderen UModel-Projekts zu inkludieren, wählenSie 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" IhresBetriebssystems): \Altova\UModel2017\UModelInclude. Beachten Sie, dass sich dieProjektdateien 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 desOrdners UModelInclude befinden.
Standardmäßig bietet UModel mehrere Projektprofile (.ump-Dateien) für Ihr UModel Projekt. Sobefinden sich etwas Java Lang-Klassen, -Schnittstellen und -Pakete auf den nach Java-Versiongeordneten Java-Registern. Auf die gleiche Weise stehen auch die .ump-Dateien für die MicrosoftC#- 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.
150 Projekte und Code Engineering Inkludieren anderer UModel-Projekte
© 2017 Altova GmbHAltova UModel 2017
So erstellen Sie im Dialogfeld "Unterprojekt inkludieren" ein benutzerdefiniertesRegister:
Navigieren Sie zum Ordner \Altova\UModel2017\UModelInclude (relativ zu IhremOrdner "Programme") und erstellen Sie Ihren benutzerdefinierten Ordner unterhalb, z.B.\UModelInclude\myfolder. Als Name des Registers im Dialogfeld "Unterrprojektinkludieren" wird der Name, den Sie dem Ordner geben, angezeigt.Kopieren Sie alle .ump-Dateien, die Sie auf dem entsprechenden Register zur Verfügungstellen 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 Siesie in denselben Ordner. So wird z.B. für die Datei MyModel.ump eine beschreibendeDatei names MyModel.txt benötigt. Stellen Sie bitte sicher, dass die Codierung dieserTextdatei UTF-8 ist.
So entfernen Sie ein inkludiertes Projekt:
1. Klicken Sie in der Modell-Strukturansicht auf das inkludierte Paket und drücken Sie dieEntf-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 "Unterprojektinkludieren":
Löschen oder entfernen Sie die .ump-Datei (MyModel.ump) aus dem entsprechendenOrdner.
© 2017 Altova GmbH
Zusammenführen von UModel-Projekten 151Projekte und Code Engineering
Altova UModel 2017
6.11 Zusammenführen von UModel-Projekten
UModel unterstützt nun 2-Weg- und 3-Weg-Projektzusammenführungen. In beiden Fällen werdenunterschiedliche UModel-Projektdateien zu einem gemeinsamen UModel *.ump Modellzusammengeführt.
Dies ist hilfreich, wenn mehrere Personen gleichzeitig am selben Projekt arbeiten oder wenn SieIhre Arbeit einfach in einem einzigen Modell zusammenführen möchten.
Nähere Informationen dazu finden Sie unter:2-Weg-Projektzusammenführung
3-Weg-Projektzusammenführung
6.11.1 2-Weg-Projektzusammenführung
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 dierelevanten Einzelheiten werden protokolliert.
Bitte beachten Sie:Wenn Sie auf einen der Einträge im Meldungsfenster klicken, wird das entsprechendeModellierungselement 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 zweitenModell haben Vorrang. So kann es z.B. nur einen Standardwert für ein Attribut geben. Eswird der Standardwert aus der zweiten Datei verwendet.Diagrammunterschiede: UModel überprüft zuerst, ob es Unterschiede zwischen denDiagrammen der beiden Modelle gibt. Wenn ja, so wird das neue/unterschiedliche Diagramm zum Modell hinzugefügt (und einefortlaufende Nummerierung wird an den Namen des Diagramms angehängt, z.B: activity1usw.) und das ursprüngliche Diagramm wird beibehalten.Falls keine Unterschiede vorhanden sind, werden identische Diagramme ignoriert und eswerden keine Änderungen vorgenommen.
152 Projekte und Code Engineering Zusammenführen von UModel-Projekten
© 2017 Altova GmbHAltova UModel 2017
Sie können anschließend entscheiden, welches der Diagramme Sie beibehalten oderlöschen möchten. Natürlich können Sie auch beide Diagramme beibehalten, wenn Siemö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 SieStrg + Z.Wenn Sie im Meldungsfenster auf einen Eintrag klicken, wird das entsprechende Elementin der Modell-Struktur angezeigt.Der Dateiname der zusammengeführten Datei, also der ersten Datei, die Sie geöffnethaben, wird beibehalten!
6.11.2 3-Weg-Projektzusammenführung
UModel unterstützt nun die Zusammenführung mehrerer UModel-Projekte, die gleichzeitig vonmehreren Entwicklern bearbeitet wurden, in einer 3-Weg-Projektzusammenführung.
ProjektzusammenführungDie 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ührungeinzelner Dateien, wenn diese Dateien nicht aufgelöste Referenzen auf andere Dateien enthalten.
Bei der Zusammenführung von Hauptprojekten werden auch alle editierbaren Unterprojekteautomatisch zusammengeführt. Die Unterprojekte müssen nicht separat zusammengeführtwerden.
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ängiggemacht werden.
Wenn Sie im Fenster "Meldungen" auf einen Eintrag klicken, wird dieses Element in derModell-Struktur angezeigt.
Der Dateiname der zusammengeführten Datei, also der ersten Datei, die Sie geöffnethaben, wird beibehalten.
Ergebnisse der Zusammenführung:Anmerkung: Mit Quelle wird im Folgenden die Anfangsprojektdatei bezeichnet, also die Datei, dieSie geöffnet haben, bevor Sie mit der Zusammenführung begonnen haben.
Neue Modellierungselemente in der zweiten Datei, also Elemente, die in der Quelle nichtvorhanden sind, werden zum zusammengeführten Modell hinzugefügt.
Neue Modellierungselemente in der Quelldatei, also Elemente, die in der zweiten Dateinicht vorhanden sind, bleiben im zusammengeführten Modell erhalten.
Gelöschte Modellierungselemente aus der zweiten Datei, also Elemente, die in derQuelle noch immer vorhanden sind, werden aus dem zusammengeführten Modell entfernt.
Gelöschte Modellierungselemente aus der Quelldatei, also Elemente, die in der zweitenDatei noch vorhanden sind, bleiben im zusammengeführten Modell gelöscht.
Unterschiede im selben Modellierungselement:
© 2017 Altova GmbH
Zusammenführen von UModel-Projekten 153Projekte und Code Engineering
Altova UModel 2017
Wenn eine Eigenschaft (z.B. die Sichtbarkeit einer Klasse) in der Quelldatei oder derzweiten Datei geändert wurde, so wird im zusammengeführten Modell der aktualisierteWert verwendet
Wenn eine Eigenschaft (z.B. die Sichtbarkeit einer Klasse) sowohl in der Quelle alsauch in der zweiten Datei geändert wurde, so wird der Wert aus der zweiten Dateiverwendet (und im Meldungsfenster unterhalb wird eine Warnmeldung angezeigt)
Verschobene Elemente: Wenn ein Element in der Quelle oder der zweiten Datei verschoben wurde, so wird dasElement im zusammengeführten Modell ebenfalls verschoben
Wenn ein Element sowohl in der Quelle als auch in der zweiten Datei (inunterschiedliche Parent-Elemente) verschoben wird, so erscheint eine Meldung, in derSie aufgefordert werden, das Parent-Element im zusammengeführten Modell manuellauszuwä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ührtenModell (mit einer fortlaufenden Nummer, wie activity1 usw.) hinzugefügt und das Originalwird beibehalten.
Wenn es keine Unterschiede gibt, so werden identische Diagramme ignoriert, d.h. es gibtkeine Änderungen.
Sie können später entscheiden, welches der Diagramme beibehalten oder gelöschtwerden soll. Natürlich können Sie auch beide Diagramme beibehalten.
Versionskontrollunterstützung für 3-Weg-ZusammenführungenBeim Ein-/Auschecken von Projektdateien generiert UModel automatisch "gemeinsameVorgängerdateien" (oder Schnappschussdateien), anhand derer anschließend die 3-Weg-Projektzusammenführung durchgeführt wird. Dies ermöglicht viel genauereZusammenführungsresultate als die normale 2-Weg-Zusammenführung.
Es hängt vom jeweiligen Versionskontrollsystem, das Sie verwenden, ab, ob UModel dieautomatische 3-Weg-Zusammenführung über die Schnappschussdatei unterstützt. Eine manuelle3-Weg-Zusammenführung ist jedoch immer möglich.
Versionskontrollsysteme, die die Dateizusammenführung durchführen, ohne dass derBenutzer darauf Einfluss nehmen kann, werden eine automatische 3-Weg-Zusammenführung wahrscheinlich nicht unterstützen.
Versionskontrollsysteme, in denen Sie bei einem geänderten Projekt zwischen Ersetzenund Zusammenführen wählen können, unterstützen eine 3-Weg-Zusammenführung imAllgemeinen. Nachdem das Versionskontroll-Plugin die Datei ersetzt hat, wird beiAuswahl des Befehls "Ersetzen" eine UModel-Dateiwarnung aktiviert, die Ihnen danngestattet, 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 ineinem Unterprojekt geändert wurden, werden Sie automatisch gefragt, ob das/dieUnterprojekte ausgecheckt werden sollen.
Bei jedem Ein-/Auscheckvorgang wird eine gemeinsame Vorgänger- oder
154 Projekte und Code Engineering Zusammenführen von UModel-Projekten
© 2017 Altova GmbHAltova UModel 2017
Schnappschussdatei erstellt, die dann für die 3-Weg-Projektzusammenführung verwendetwird.
Bitte beachten Sie:Schnappschussdateien werden nur mit den Standalone-Versionen von UModelautomatisch erstellt und verwendet, d.h. diese Funktionen stehen in der Eclipse- und derVisual Studio-Plugin-Version nicht zur Verfügung.
BeispielBenutzer A bearbeitet eine UModel-Projektdatei und ändert den Namen einer Klasse imBankView-Hauptdiagramm. Benutzer B öffnet dieselbe Projektdatei und ändert die Sichtbarkeitderselben Klasse.
Anhand der Schnappschussdateien, die für die einzelnen Benutzer erstellt wurden, wird einBearbeitungsverlauf erstellt, der eine Zusammenführung der einzelnen Änderungen im Projektermöglicht. Sowohl die Änderungen am Namen als auch an der Sichtbarkeit werden bei der 3-Weg-Zusammenführung in der Projektdatei zusammengeführt.
6.11.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 inuntergeordnete 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 ander 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.
© 2017 Altova GmbH
Zusammenführen von UModel-Projekten 155Projekte und Code Engineering
Altova UModel 2017
3. Anschließend wird das Projekt gespeichert.
User2 öffnet die Projektdatei Bank_CSharp.ump im Ordner C#_2 und nimmt Änderungen an derBank-Klasse vor.
Änderungen an der Bank-Klasse:1. Die Operationen CollectAccountInfos... und GetBalanceOfAccounts... werden beiden
von "public" in "protected" geändert.
156 Projekte und Code Engineering Zusammenführen von UModel-Projekten
© 2017 Altova GmbHAltova UModel 2017
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.
Sie werden nun aufgefordert, die gemeinsame Vorgängerdatei zu öffnen. Dabei handeltes sich um die Originalprojektdatei im Ordner ...\UModelExamples.
© 2017 Altova GmbH
Zusammenführen von UModel-Projekten 157Projekte und Code Engineering
Altova UModel 2017
Die 3-Weg-Zusammenführung wird gestartet und sie kehren zur Projektdatei, von der ausSie 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 ProjektdateiC#_2 repliziert.
Die am Projekt im Ordner C#_2 vorgenommenen Änderungen werden in der Projektdateibeibehalten.
Bei 3-Weg-Zusammenführungen zwischen den Projektdateien in den Ordnern C#_1 undC#_2 sollte nun in Zukunft die Projektdatei im Ordner C#_2 sollte als gemeinsameVorgängerdatei verwendet werden.
158 Projekte und Code Engineering Freigeben von Paketen und Diagrammen
© 2017 Altova GmbHAltova UModel 2017
6.12 Freigeben von Paketen und Diagrammen
UModel gestattet Ihnen, Pakete und eventuell darin enthaltene UML-Diagramme freizugeben undin mehreren Projekten zu verwenden. Pakete können mittels Referenz oder in Form einer Kopie inandere UModel-Projekte inkludiert werden.
Beachten Sie bitte außerdem, dass Unterprojektdateien jederzeit von einem Haupt- oderUnterprojekt abgeteilt werden können. Die Unterprojektdateien können vom Hauptprojekt aus alseditierbare oder als schreibgeschützte Projekte inkludiert werden; die einzelnen Pakete werdenfreigegeben und als Unterprojektdatei gespeichert und können zu einem Versionskontrollsystemhinzugefügt werden. Nähere Informationen dazu finden Sie unter Unterstützung für die Arbeit imTeam an UModel-Projekten.
Voraussetzungen für freigegebene Pakete:Objektbeziehungen zu anderen Paketen außerhalb des freigegebenen Bereichs sind nichtzulässig.
Anmerkung: Wenn Sie UModel-Projektdateien erstellen, verwenden Sie nicht eine einzige Projektdateials "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 mitidentischen 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"-Symbolangezeigt. Dieses Paket kann nun in jedes beliebige andere UModel-Projekt inkludiertwerden.
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
© 2017 Altova GmbH
Freigeben von Paketen und Diagrammen 159Projekte und Code Engineering
Altova UModel 2017
freigegebene Paket enthält, aus und klicken Sie auf "Öffnen".
Im Dialogfeld "Inkludieren" können Sie das Paket/Projekt in Form einer Referenz oder alsKopie 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 desPakets wird in Klammern angezeigt (BankView-start.ump).
Freigegebene Ordner, die in Form einer Referenz inkludiert wurden, können jederzeitdurch Auswahl von Unterprojekt | Als Kopie inkludieren in "als Kopie" geändertwerden.
Bitte beachten Sie:Alle inkludierten Projekte des Quellprojekts wurden ebenfalls inkludiert: Java Lang,Unknown Externals und Java Profile.
Freigegebene Pakete - Objektbeziehungen zu externen Elementen:
160 Projekte und Code Engineering Freigeben von Paketen und Diagrammen
© 2017 Altova GmbHAltova UModel 2017
Wenn Sie versuchen, ein Paket freizugeben, das Objektbeziehungen zu externen Elementenenthä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 dasProjekt speichern können.
Im Meldungsfenster werden Informationen zu den einzelnen externen Objektbeziehungenangezeigt.
Wenn Sie im Meldungsfenster auf eine Fehlermeldung klicken, wird das entsprechende Elementauf dem Register "Modell-Struktur" angezeigt.
© 2017 Altova GmbH
Freigeben von Paketen und Diagrammen 161Projekte und Code Engineering
Altova UModel 2017
162 Projekte und Code Engineering UML-Vorlagen
© 2017 Altova GmbHAltova UModel 2017
6.13 UML-Vorlagen
UModel unterstützt die Verwendung von UML-Vorlagen (Templates) und das Mappen dieserVorlagen auf oder von Java-, C#- und Visual Basic Generics.
Vorlagen (Templates) sind "potentielle" Modellelemente mit nicht gebundenen formalenParametern. Diese parametrisierten Modellelemente beschreiben eine Gruppe von Modellelementeneines bestimmten Typs: Classifier oder Operationen.Vorlagen können nicht direkt als Typen verwendet werden. Die Parameter müssengebunden 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 neuesModellelement (ein gebundenes Element) auf Basis der Vorlage erzeugt.Bei Vorhandensein mehrerer einschränkender Classifier in C# können dieVorlagenparameter direkt auf dem Register "Eigenschaften" bearbeitet werden, wenn derVorlagenparameter ausgewählt ist.
Anzeige der Vorlagensignatur in UModel:
Klassenvorlage mit dem Namen MyVector mit dem formalen Vorlagenparameter "T", derin einem gestrichelten Rechteck angezeigt wird.Formale Parameter ohne Typinfo (T ) sind implizit Classifier: Class, Datatype,Enumeration, PrimitiveType, Interface. Alle anderen Parametertypen müssen explizitangezeigt 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 intvectorVorlage vom Typ MyVector, wobeider Parameter T durch int ersetzt wird"Ersetzt durch" wird angezeigt durch - >.
Verwendung von Vorlagen in Eigenschaften/Operationen:
© 2017 Altova GmbH
UML-Vorlagen 163Projekte und Code Engineering
Altova UModel 2017
Eine anonyme Vorlagenverwendung:Eigenschaft MyFloatVector vom Typ MyVector<T->float>
Vorlagen können auch beim Definieren von Eigenschaften oder Operationen definiert werden. DieAutokomplettierungsfunktion hilft Ihnen, die Syntaxvorgaben einzuhalten.
Operation1 gibt einen Vektor von floats zurück.
6.13.1 Vorlagensignaturen
Eine Vorlagensignatur ist ein String, der die formalen Vorlagenparameter definiert. Eine Vorlage(Template) ist ein parametrisiertes Element, das zum Generieren neuer Modellelementeverwendet wird, indem die formalen Parameter durch tatsächliche Parameter (Werte) ersetztwerden bzw. daran gebunden werden.
Formaler VorlagenparameterTVorlage mit einem einzigen formalen Parameter, ohne Typenkonzept(speichert Elemente vom Typ T)
Multiple formale VorlagenparameterKeyType:DateType, ValueType
ParameterersetzungT>aBaseClass
Die Parametersubstitution muss vom Typ "aBaseClass" oder davon abgeleitet sein.
Standardwerte für VorlagenparameterT=aDefaultValue
Ersetzen von ClassifiernT>{contract}aBaseClass
allowsSubstitutable is trueDer Parameter muss ein Classifier sein, der an die Stelle des Classifiers gesetzt werdenkann, der durch den Classifier-Namen definiert ist.
Einschränken von VorlagenparameternT:Interface>anInterface
Wenn Sie Parameter auf etwas anderes als eine Klasse einschränken wollen(Schnittstelle, Datentyp), wird die Einschränkung nach dem ":"-Zeichen angezeigt. Sowird T z.B. an eine Schnittstelle gebunden (T:Interface) die vom Typ
164 Projekte und Code Engineering UML-Vorlagen
© 2017 Altova GmbHAltova UModel 2017
"anInterface" (>anInterface) sein muss.
Verwendung von Platzhalterzeichen in VorlagensignaturenT>vector<T->?<aBaseClass>
Der Vorlagenparameter T muss vom Typ "vector" sein, der Objekte enthält, die einübergeordneter Typ von aBaseClass sind.
Erweitern von VorlagenparameternT>Comparable<T->T>
6.13.2 Vorlagenverwendung
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 gebundeneKlassen. Vorlagenverwendungen können wie unten gezeigt im Klassennamen-Feld definiertwerden.
Ersetzen/Binden von formalen ParameternVektor <T->int>
Erstellen von Vorlagenverwendungen über den Klassennamena_float_vector:vector<T->float>
Binden von mehreren Vorlagen gleichzeitigClass5: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>
6.13.3 Vorlagenverwendung in Operationen und Eigenschaften
Operation, die eine gebundene Vorlage zurückgibtClass1Operation1():vector<T->int>
Der Parameter T ist an "int" gebunden. Operation1 gibt einen Vektor von ints zurück.
Klasse, die eine Vorlagenoperation enthältClass1Operation1<T>(in T):T
© 2017 Altova GmbH
UML-Vorlagen 165Projekte und Code Engineering
Altova UModel 2017
Verwenden von PlatzhalterzeichenClass1Property1:vector<T->?>
Diese Klasse enthält einen generischen Vektor eines nicht spezifizierten Typs (? ist dasPlatzhalterzeichen).
Typisierte Eigenschaften können als Assoziationen angezeigt werden:
Rechtsklicken Sie auf eine Eigenschaft und wählen Sie Anzeigen | PropertyX alsAssoziation oder
Ziehen Sie eine Eigenschaft auf den Diagrammhintergrund.
166 Projekte und Code Engineering Projekteinstellungen
© 2017 Altova GmbHAltova UModel 2017
6.14 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.
© 2017 Altova GmbH
Verbesserung der Performance 167Projekte und Code Engineering
Altova UModel 2017
6.15 Verbesserung der Performance
Da Modellierungsprojekte manchmal relativ groß werden können, gibt es Möglichkeiten, diePerformance 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 eineeinheitliche Farbe. z.B: Register "Stile" | Diag. Hintergrundfarbe | Weiß.Die automatisch aktivierte Autokomplettierung kann über Extras | Optionen |Diagrambearbeitung und Deaktivieren des Kontrollkästchens "AutomatischeEingabehilfe aktivieren" deaktiviert werden.
Kapitel 7
Erstellen von Modellbeziehungen
170 Erstellen von Modellbeziehungen
© 2017 Altova GmbHAltova UModel 2017
7 Erstellen von Modellbeziehungen
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 derVerbindungen zwischen den Elementen mittels Drag-and-Drop.
Assoziationssymbol
Aggregation
Komposition
Enthältbeziehung
Nachdem eine Assoziation erstellt wurde, wird automatisch ein neues Attribut in dieUrsprungsklasse (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 MemberEnd 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 demRegister "Eigenschaften" angezeigt. A:Name und B:Name geben die Rolle der jeweiligen Klassein der anderen an.
© 2017 Altova GmbH
171Erstellen von Modellbeziehungen
Altova UModel 2017
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 nichtangezeigt).
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 dasAttribut weiterhin Teil der Assoziation, doch wird der Navigierbarkeitspfeil wieder angezeigt, jenachdem 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 Standardassoziationshared: eine Aggregationsassoziationcomposite: eine Kompositionsassoziation
Bitte beachten Sie:Assoziationen können mit derselben Klasse als Quelle und Ziel erstellt werden. Dabeihandelt es sich um ein so genanntes "self link". Dies beschreibt die Fähigkeit einesObjekts, bei rekursiven Aufrufen eine Nachricht an sich selbst zu senden.
Klicken Sie auf das Beziehungssymbol und ziehen Sie es anschließend vom Element aneine andere Stelle desselben Elements. Daraufhin wird eine Objektbeziehung auf sichselbst angezeigt.
Automatische Anzeige von Assoziationen in Diagrammen
172 Erstellen von Modellbeziehungen
© 2017 Altova GmbHAltova UModel 2017
Beim Einfügen von Diagrammelementen in ein Diagramm können bestehende Assoziationenzwischen Modellelementen mit Hilfe der Option "Assoziationen automatisch erstellen" von demRegister Extras | Optionen | Bearbeiten automatisch im aktuellen Diagramm erstellt/angezeigtwerden. Dies geschieht, wenn der Typ des Attributs definiert ist und das referenzierteModellelement 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.2. Drücken Sie die Entf-Taste.
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 haben2. 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- unduntergeordneten 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 einemBereich von Class1 zu sehen ist. Dadurch wird die enthaltene Klasse im Allgemeinen indenselben Namespace platziert wie die enthaltende Klasse.
© 2017 Altova GmbH
Anzeigen von Modellbeziehungen 173Erstellen von Modellbeziehungen
Altova UModel 2017
7.1 Anzeigen von Modellbeziehungen
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 Optionenzur 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 undwä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.
174 Erstellen von Modellbeziehungen Anzeigen von Modellbeziehungen
© 2017 Altova GmbHAltova UModel 2017
2. Wählen Sie die Menüoption Anzeigen | "EigenschaftXX" als Assoziation.Daraufhin wird die referenzierte Klasse eingefügt/geöffnet und die jeweilige Assoziationwird angezeigt.
© 2017 Altova GmbH
Assoziationen, Realisierungen und Abhängigkeiten 175Erstellen von Modellbeziehungen
Altova UModel 2017
7.2 Assoziationen, Realisierungen und Abhängigkeiten
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 diesemZiehpunkt erstellt wird, angezeigt - in diesem Fall "Assoziation".
4. Ziehen Sie, um eine Verbindungslinie zu erstellen, die Linie auf die zweite Klasse. DieZielklasse 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 Collection-Assoziation erstellt wird.
Für die Elemente in den verschiedenen Modelldiagrammen stehen verschiedeneVerbindungsziehpunkte zur Verfügung.So stehen z.B. bei einer Klasse in einem Klassendiagramm Ziehpunkte für die folgendenBeziehungen zur Verfügung (im Uhrzeigersinn):
SchnittstellenrealisierungGeneralisierungAssoziation
Ein Artefakt in der Deployment-Ansicht hat die folgenden Ziehpunkte:ManifestationAssoziationVerteilung
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.
176 Erstellen von Modellbeziehungen Assoziationen, Realisierungen und Abhängigkeiten
© 2017 Altova GmbHAltova UModel 2017
2. Ziehen Sie es von einem Objekt auf das andere und lassen Sie die Maustaste los, wenndas Zielelement markiert erscheint.
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 nichtgezeigt.
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.2. Drücken Sie die Entf-Taste.
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. EineKlasseneigenschaft (z.B. Schnittstelle) kann im Allgemeinen als Assoziation zum "Typ" derEigenschaft angezeigt werden. UModel bietet zusätzlich dazu eine alternative Methode, um dieseArt von Assoziation anzuzeigen.
Klicken Sie auf den unteren der beiden Klassenziehpunkte auf der rechten Seite der Klasse undziehen Sie den Konnektor anschließend auf die Zielklasse.
© 2017 Altova GmbH
Assoziationen, Realisierungen und Abhängigkeiten 177Erstellen von Modellbeziehungen
Altova UModel 2017
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 Siesie als Collection-Assoziationen, wenn die Einstellungen auf dem Register zurDiagrammbearbeitung 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 "Collectionvon" Colors ist.Die Assoziation wird nicht als List<E->Color> angezeigt, sondern verweist direkt auf dieEnumeration "Color", wodurch die Information, dass Color in einem Template Binding verwendetwird, nicht sichtbar ist.
Der konkrete Collection-Typ von "myColors" wird immer noch im myColorsContainer, nicht aber inder Assoziation angezeigt.
Über das Register "Diagrammbearbeitung" des Dialogfelds Extras | Optionen können Sie die
178 Erstellen von Modellbeziehungen Assoziationen, Realisierungen und Abhängigkeiten
© 2017 Altova GmbHAltova UModel 2017
Vorlagen definieren, in denen dieses Verhalten angewendet werden soll und ob die Collectionsaufgelöst werden sollen.
Kapitel 8
Generieren von UML-Dokumentation
180 Generieren von UML-Dokumentation
© 2017 Altova GmbHAltova UModel 2017
8 Generieren von UML-Dokumentation
Altova Website: UML-Projektdokumentation
Mit dem Befehl Dokumentation generieren wird detaillierte Dokumentation zu Ihrem UML-Projekt in den Formaten HTML, MS Word, RTF oder PDF generiert. Mit diesem Befehl generierteDokumentation kann beliebig geändert und verwendet werden; Sie benötigen dazu keineGenehmigung 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 Designverwenden oder ein StyleVision SPS für das Design verwenden. Bei Verwendung einesStyleVision SPS können Sie die Ausgabe der generierten Dokumentation anpassen. EineAnleitung dazu finden Sie im Abschnitt Benutzerdefinierte Stylesheets.
Anmerkung: Bei Generierung von Dokumentation mit Hilfe eines SPS müssen Sie StyleVisionauf Ihrem Rechner installiert haben. Miteinander in Beziehung stehende Elemente sind inder Bildschirmausgabe normalerweise durch einen Link verbunden, um die Navigation voneiner Komponente zur anderen zu erleichtern.
Um Dokumentation im Format MS Word zu generieren, muss MS Word (Version 2000oder 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 untensehen Sie die Standardeinstellungen des Dialogfelds.
© 2017 Altova GmbH
181Generieren von UML-Dokumentation
Altova UModel 2017
Beachten Sie: Sie können auch einzelne Teile eines Projekts dokumentieren. RechtsklickenSie dazu in der Modellstruktur auf ein Element (bzw. mit Strg + Klick auf mehrere Elemente) undwä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ällendieselben. Miteinander in Beziehung stehende Elemente werden in der Ausgabe auf dem Bildschirm durchHyperlinks miteinander verbunden, sodass Sie von Komponente zu Komponente navigierenkö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 VB-Unterprojekte (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 vordefinierteDokumentationsvorlage zu verwenden.
Wählen Sie die Option "Für ein benutzerdefiniertes Design..." um ein vordefiniertes, inStyleVision erstelltes StyleVision Power Stylesheet zu verwenden. Die SPS-Dateienfinden 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 ineinem 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 sieanhand 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 anhandeines StyleVision SPS generieren.
Mit der Option Ausgabe auf mehrere Dateien aufteilen wird für jedesModellierungselement, das bei Generierung einer einzigen Ausgabedatei in derInhaltsverzeichnisübersicht zu sehen ist, eine Ausgabedatei erstellt. Z.B. gibt es eineKlasse C1 mit einer geschachtelten Klasse CNest; C1.html enthält alle Informationen zuC1 und CNest sowie alle ihre Attribute und Eigenschaften usw.
Mit der Option CSS in HTML einbetten können Sie eine vorhandene (referenzierte) CSS-Datei in die HTML-Dokumentation einbetten. Wenn Sie die Option deaktivieren, wird dieReferenz zur CSS-Datei beibehalten und die Datei selbst bleibt extern.
Die Option Diagramme einbetten ist für die Ausgabeoptionen MS Word und RTFaktiviert. Wenn diese Option ausgewählt ist, werden Diagramm in die generierte Dateieingebettet. Diagramme werden als PNG-Dateien (für HTML) oder PNG/EMF-Dateien (fürMS Word und RTF) erstellt und über Objektlinks in der Ergebnisdatei angezeigt.
182 Generieren von UML-Dokumentation
© 2017 Altova GmbHAltova UModel 2017
Mit der Option Ordner für Diagramme erstellen wird unterhalb des ausgewähltenAusgabeordners ein Unterordner erstellt, der bei Ausgabe der Dokumentation alleDiagramme enthält.
´Die Option Ergebnisdatei...anzeigen ist für alle Ausgabeoptionen aktiviert. Wenn dieOption aktiv ist, werden die Ergebnisdateien in der Browser-Ansicht (HTML-Ausgabe), MSWord (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 diegenerierten Links absolute oder relative Links zur Ausgabedatei sein sollen.
Register "Inkludieren"Auf dem Register Inkludieren können Sie auswählen, welche Diagramme undModellierungselemente 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 Dokumentationaufscheinen 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 Verschachtelungstiefefestlegen, die im Hierarchiediagramm oberhalb / unterhalb der aktuellen Klasse angezeigtwerden soll.
© 2017 Altova GmbH
183Generieren von UML-Dokumentation
Altova UModel 2017
Mit der Option "Jedes Element nur einmal erweitern" wird nur immer jeweils ein Classifierim selben Bild/Diagramm erweitert.
Register "Schriftarten"Auf dem Register "Schriftarten" können Sie die Schriftarteinstellungen für die verschiedenenÜberschriften und Textinhalte anpassen.
184 Generieren von UML-Dokumentation
© 2017 Altova GmbHAltova UModel 2017
In den folgenden Abbildungen sehen Sie die mit dem festgelegten Design generierteDokumentation für die Datei Bank_MultiLanguage.ump aus dem Verzeichnis ...\UModelExamples.
In der Abbildung oben sehen Sie die generierte Dokumentation mit den Diagramm- undElementindexlinks in oberen Bereich der HTML-Datei.
© 2017 Altova GmbH
185Generieren von UML-Dokumentation
Altova UModel 2017
In der Abbildung unten sehen Sie die näheren Informationen zur Klasse "Account" sowie ihreBeziehung zu anderen Klassen.
Beachten Sie, dass die einzelnen Attribute und Eigenschaften in den Klassendiagrammenebenfalls mittels Hyperlinks mit ihren Definitionen verknüpft sind. Wenn Sie auf eine Eigenschaftklicken, gelangen Sie zu ihrer Definition. Die einzelnen Hierarchieklassen sowie der gesamteunterstrichene Text sind durch Hyperlinks verbunden.
186 Generieren von UML-Dokumentation Vordefiniertes SPS-Stylesheet
© 2017 Altova GmbHAltova UModel 2017
8.1 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
© 2017 Altova GmbH
Vordefiniertes SPS-Stylesheet 187Generieren von UML-Dokumentation
Altova UModel 2017
entsprechenden Modellierungselement im Browser.
188 Generieren von UML-Dokumentation Benutzerdefinierte Stylesheets
© 2017 Altova GmbHAltova UModel 2017
8.2 Benutzerdefinierte Stylesheets
Anstatt das festgelegte Design zu verwenden, können Sie auch ein benutzerdefiniertes Design fürdie UModel-Dokumentation erstellen. Das benutzerdefinierte Design wird in einem StyleVisionSPS erstellt. Beachten Sie, dass das vordefinierte SPS Stylesheet bereits im Lieferumfang vonUModel inkludiert ist.
Definition des SPS für die Verwendung für die UModel-DokumentationDas 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, mussStyleVision auf Ihrem Rechner installiert sein.
Erstellung des SPSEin 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, dasdie Struktur des XML-Dokuments definiert, das die UModel-Dokumentation enthält.
Dieses Schema hat den Namen UModelDocumentation.xsd und ist in Ihrem UModel-Installationspaket enthalten. Es befindet sich im Ordner ...\My Documents\Altova\UModel2017\Documentation\UModel.
Bei Erstellung des SPS-Designs in StyleVision werden Nodes aus dem SchemaUModelDocumentation.xsd in das Design gezogen und diese Nodes erhalten Stile undEigenschaften zugewiesen. Beachten Sie, dass UModelDocumentation.xsd die DateiDocumentation.xsd aus dem übergeordneten Ordner enthält.
Des Weiteren können zusätzliche Komponenten wie z.B. Links und Bilder ebenfalls zum SPS-Design hinzugefügt werden. Eine Anleitung zur Erstellung eines SPS Designs in StyleVisionfinden Sie im Benutzerhandbuch zu StyleVision.
Der Vorteil bei der Generierung der Dokumentation anhand eines SPS ist, dass Sie völlig freieHand bei der Gestaltung der Dokumentation haben. Beachten Sie außerdem, dass die PDF-Ausgabe der Dokumentation nur bei Verwendung eines SPS zur Verfügung steht; bei Verwendung
© 2017 Altova GmbH
Benutzerdefinierte Stylesheets 189Generieren von UML-Dokumentation
Altova UModel 2017
des festgelegten Designs steht die PDF-Ausgabe nicht zur Verfügung.
Kapitel 9
UML-Diagramme
192 UML-Diagramme
© 2017 Altova GmbHAltova UModel 2017
9 UML-Diagramme
UML-Diagramme werden in zwei große Gruppen eingeteilt: Strukturdiagramme, in denen einestatische Ansicht des Modells zu sehen ist, und Verhaltensdiagramme, in denen die dynamischeAnsicht dargestellt wird. UModel unterstützt alle vierzehn Diagramme der UML 2.4-Spezifikationsowie XML-Schema- und Business Modeling Notation-Diagramme.
Zu den Verhaltensdiagrammen gehören Aktivitäts-, Zustands-, Protokoll-Zustands- und Use Case-Diagramme 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 meistenModellierungsdiagramme erstellt werden, z.B. Lebenslinienbeschriftungen in Sequenzdiagrammen, Zeitverlaufsdiagrammen; Guard-Bedingungen, Zustandsnamen,Aktivitätsnamen usw.
© 2017 Altova GmbH
Verhaltensdiagramme 193UML-Diagramme
Altova UModel 2017
9.1 Verhaltensdiagramme
In diesen Diagrammen werden Verhaltensaspekte eines Systems oder Geschäftsvorgangsbeschrieben. Sie enthalten eine Untergruppe von Diagrammen zur Darstellung derWechselbeziehungen zwischen Objekten.
Verhaltensdiagramme
Aktivitätsdiagramm
Zustandsdiagramm
Protokoll-Zustandsdiagramm
Use Case-Diagramm
Eine Untergruppe der Verhaltensdiagramme bilden jene zur Darstellung von Wechselwirkungenzwischen Objekten:
Kommunikationsdiagramm
Interaktionsübersichtsdiagramm
Sequenzdiagramm
Zeitverlaufsdiagramm
9.1.1 Aktivitätsdiagramm
Altova Website: UML-Aktivitätsdiagramm
Aktivitätsdiagramme eignen sich, um reale Arbeitsabläufe von Geschäftsprozessen zu modellierenund um anzuzeigen, welche Aktionen dabei erforderlich sind und welche Abhängigkeiten diesehaben. Im Aktivitätsdiagramm wird die Reihenfolge von Aktivitäten beschrieben. Es wird sowohlbedingte als auch parallele Verarbeitung unterstützt. Das Aktivitätsdiagramm ist eine Variante desZustandsdiagramms, wobei die Zustände hier Aktivitäten sind.
Bitte beachten Sie, dass das im folgenden Abschnitt gezeigte Aktivitätsdiagramm im UModel-Ordner ...\UModelExamples im Beispiel Bank_MultiLanguage.ump zur Verfügung steht.
194 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Einfügen von Aktivitätsdiagrammelementen9.1.1.1
Verwendung der Symbolleistenschaltflächen:1. Klicken Sie in der Aktivitätsdiagrammsymbolleiste auf das gewünschte
Aktivitätsdiagramm-Symbol.
© 2017 Altova GmbH
Verhaltensdiagramme 195UML-Diagramme
Altova UModel 2017
2. Klicken Sie in das Aktivitätsdiagramm, um das Element einzufügen. Um mehrereElemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt undklicken Sie in das Diagrammfenster.
Ziehen bestehender Elemente in das Aktivitätsdiagramm:Die meisten Elemente, die in anderen Aktivitätsdiagrammen vorkommen, können in einbestehendes Aktivitätsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (Sie könnendas 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) undanschließend in das Aktivitätsdiagramm, um es einzufügen.
2. Geben Sie den Namen der Aktion ein, z.B. "Validate References" (=Referenzenvalidieren) und drücken Sie zur Bestätigung die Eingabetaste.
Anmerkung: Durch Drücken von Strg+Eingabetaste können Sie einen mehrzeiligenNamen erstellen.
Einfügen einer Aktion (Aufrufoperation) und Auswählen einer bestimmten Operation:
1. Klicken Sie in der Symbolleiste auf das Symbol "Aktion (Aufrufoperation)" undanschließend in das Aktivitätsdiagramm um es einzufügen.
2. Geben Sie den Namen der Aktion ein, z.B. collectAccountInfo und drücken Sie zurBestätigung die Eingabetaste.
3. Klicken Sie auf dem Register "Eigenschaften" auf die Durchsuchen-Schaltfläche rechtsvom Feld "Operation".
196 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Daraufhin wird das Dialogfeld "Operation auswählen" geöffnet. Hier können Sie diegewü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".
Erstellen von Verzweigungen und Merges9.1.1.2
Erstellen einer Verzweigung (alternativer Fluss)Eine Verzweigung hat einen einzigen eingehenden Fluss und mehrere mit "Guards" verseheneausgehende Flüsse. Es kann nur einer der ausgehenden Flüsse ausgewählt werden, daher solltendie Guards einander gegenseitig ausschließen.
In diesem Beispiel müssen die (BankView) Referenzen validiert werden.branch1 (Verzweigung1) hat den Guard "reference missing" (=Referenz fehlt). DieseTransition endet im Abbruch der Aktivität.branch2 hat den Guard "valid" (= gültig). Diese Transition führt zur Aktivität
© 2017 Altova GmbH
Verhaltensdiagramme 197UML-Diagramme
Altova UModel 2017
collectAccountInfos (Kontoinformationen abrufen).
1. Klicken Sie in der Symbolleiste auf das Symbol Verzweigungsknoten und fügenSie das Element im Aktivitätsdiagramm ein.
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ßendauf den rechten Ziehpunkt Kontrollfluss und ziehen Sie den Konnektor, der angezeigtwird, 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ähereInformationen dazu finden Sie unter "Einfügen einer Aktion (Aufrufoperation)".
5. Geben Sie auf dem Register "Eigenschaften" die Guard-Bedingung "valid" ein.
198 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
6. Klicken Sie auf das Verzweigungsknotenelement und ziehen Sie den rechtenZiehpunkt 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 nichtvalidiert oder überprüft.
Erstellen eines Merge:
1. Klicken Sie in der Symbolleiste auf das Verbindungsknotensymbol undanschließend in das Aktivitätsdiagramm, um es einzufügen.
2. Klicken Sie auf die Kontrollfluss (Objektfluss)-Ziehpunkte der zu vereinigenden Aktionenund ziehen Sie die Pfeile auf das Verbindungsknotensymbol.
© 2017 Altova GmbH
Verhaltensdiagramme 199UML-Diagramme
Altova UModel 2017
Aktivitätsdiagramm-Elemente9.1.1.3
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 Platzhalterverwendet werden, bis fest steht, welche spezifische Aktion verwendet werden soll.
Aktion (ValueSpecificationAction)Eine Art von Aktion zum Auswerten (/Generieren)
EreignisannahmeaktionFügt die Ereignisannahmeaktion ein, welche auf das Eintreten eines Ereignisses wartet, dasbestimmte Bedingungen erfüllt.
Ereignisannahmeaktion (Zeitereignis)Fügt eine Ereignisannahmeaktion ein, die durch ein Zeitereignis ausgelöst wird, welches ein
200 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Zeitintervall - z.B. 1 sec since last update - mit einem Ausdruck definiert.
SignalsendeaktionFügt die Signalsendeaktion ein. Dabei wird ein Signal von den Inputs erstellt. Dieses Signal wirdan das Zielobjekt übertragen, wo es die Ausführung einer Aktivität auslösen kann.
VerzweigungsknotenFügt einen Verzweigungsknoten ein, welcher eine einzige eingehende Transition hat und mehrereausgehende mit Guards versehene Transitionen. Nähere Informationen dazu finden Sie unter"Erstellen einer Verzweigung".
VerbindungsknotenFügt einen Verbindungsknoten ein, der mehrere durch einen Verzweigungsknoten definiertealternative Transitionen zusammenführt. Die gleichzeitig ablaufenden Prozesse werden dabei nichtsynchronisiert, sondern es wird einer der Prozesse ausgewählt.
StartknotenDer Anfang der Aktivität. Eine Aktivität kann mehrere Startknoten haben.
© 2017 Altova GmbH
Verhaltensdiagramme 201UML-Diagramme
Altova UModel 2017
AktivitätsendknotenDas Ende der Aktivität. Eine Aktivität kann mehrere Endknoten haben. Alle Flüsse in der Aktivitätwerden beendet, wenn der "erste" Endknoten erreicht wird.
Endknoten für KontrollflüsseFügt den Endknoten für Kontrollflüsse ein, d.h. ein Fluss wird dadurch beendet. Diese Beendunghat keinen Einfluss auf andere Flüsse in der Aktivität.
ParallelisierungsknotenFü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.
SynchronisationsknotenFügt einen vertikalen Parallelisierungsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch einen Parallelisierungsknoten definierteFlüsse.
Synchronisationsknoten (horizontal)Fügt einen horizontalen Parallelisierungsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch einen Parallelisierungsknoten definierteFlüsse.
InputPinFügt einen Input Pin in ein Aufrufverhalten oder eine Aufrufoperation ein. Input Pins liefernEingabewerte, die von einer Aktion verwendet werden. Ein Input Pin erhält automatisch denStandardnamen "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 Mausziehen, wird es am Rand des Elements neu positioniert.
OutputPinFügt eine Output Pin-Aktion ein. Output Pins enthalten Werte, die von einer Aktion erzeugt
202 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
werden. Dem Output Pin wird automatisch ein Name zugewiesen, der der UML-Eigenschaft dieserAktion - 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, wirdes am Rand des Elements neu positioniert.
Ausnahmepin Ein Output Pin kann durch Klicken auf den Pin und Auswahl der Option "isExceptionPin" imFenster "Eigenschaften" in einen Ausnahmepin umgewandelt werden.
WertpinFügt einen Wertpin ein. Dabei handelt es sich um einen Input Pin, der für eine Aktion einen Wertbereitstellt, der nicht aus einem eingehenden Objektfluss stammt. Er wird als ein Input Pin-Symbol dargestellt und hat dieselben Eigenschaften wie ein Input Pin.
ObjektknotenFügt einen Objektknoten ein. Ein Objektknoten ist ein abstrakter Aktivitätsknoten, der denObjektfluss in einer Aktivität definiert. Objektknoten können nur Werte zur Laufzeit enthalten, diedem Typ des Objektknotens entsprechen.
PufferknotenFügt einen Pufferknoten ein, der als Puffer für mehrere eingehende und ausgehende Flüsse vonanderen Objektknoten dient.
DatenspeicherknotenFügt einen Datenspeicherknoten ein. Dabei handelt es sich um einen speziellen Pufferknoten, derzum 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 vonAktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaften gemeinsamhaben. Dies entspricht oft Organisationseinheiten in einem Geschäftsmodell.
© 2017 Altova GmbH
Verhaltensdiagramme 203UML-Diagramme
Altova UModel 2017
Wenn Sie auf eine Beschriftung doppelklicken, lässt sich diese direkt editieren; bei Drücken derEingabetaste 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 dieUmrandung markiert erscheint.
Objekte innerhalb einer ActivityPartition können mit Hilfe von Strg+Klick oder durchAufziehen 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 vonAktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaften gemeinsamhaben. Dies entspricht oft Organisationseinheiten in einem Geschäftsmodell.
Aktivitätsbereich (2 Dimensionen)Fügt einen zweidimensionalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art vonAktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaften gemeinsamhaben. Beide Achsen haben editierbare Beschriftungen.
204 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
So entfernen Sie die Dim1, Dim2-Beschriftungen:1. Klicken Sie auf die Dimensionsbezeichnung, die Sie entfernen möchten z.B. Dim12. 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.
KontrollflussEin Kontrollfluss ist eine Kante, d.h. ein Pfeil, der zwei Aktivitäten/Verhalten verbindet und eineAktivität startet, nachdem die vorherige zu Ende geführt wurde.
© 2017 Altova GmbH
Verhaltensdiagramme 205UML-Diagramme
Altova UModel 2017
ObjektflussEin Objektfluss ist eine Kante, d.h. ein Pfeil, der zwei Aktionen/Objektknoten verbindet und eineAktivität startet, sobald die vorherige zu Ende geführt worden ist. Entlang eines Objektflusseskönnen Objekte oder Daten übergeben werden.
Ausnahme-HandlerEin Ausnahme-Handler ist ein Element, das festlegt, welche Aktion ausgeführt werden soll, wennwährend der Ausführung des geschützten Knotens ein bestimmtes Ausnahmeereignis auftritt.
Ein Ausnahme-Handler kann nur auf einen Inputpin einer Aktion gezogen werden.
AktivitätFügt eine Aktivität in das Aktivitätsdiagramm ein.
206 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
AktivitätsparameterknotenFügt einen Aktivitätsparameterknoten in eine Aktivität ein. Wenn Sie an eine beliebige Stelle inder Aktivität klicken, wird der Parameterknoten auf den Rand der Aktivität platziert.
StrukturierterAktivitätsknotenFügt einen strukturierten Aktivitätsknoten ein. Dabei handelt es sich um einen strukturierten Teilder Aktivität, der mit keinem anderen strukturierten Knoten geteilt wird.
MengenverarbeitungsbereichEin Mengenverarbeitungsbereich ist ein Bereich einer Aktivität mit expliziten Inputs und Outputs(über Erweiterungsknoten). Jeder Input ist eine Sammlung von Werten.
© 2017 Altova GmbH
Verhaltensdiagramme 207UML-Diagramme
Altova UModel 2017
Der Mengenverarbeitungsbereichsknoten wird als Schlüsselwort angezeigt und kann durchKlicken auf die Auswahlliste "Modus" auf dem Register "Eigenschaften" geändert werden. ZurAuswahl stehen die Einstellungen: parallel, iterative oder stream.
ErweiterungsknotenFügt einen Erweiterungsknoten in einen Mengenverarbeitungsbereich ein. Erweiterungsknotensind Eingabe- und Ausgabeknoten für den Mengenverarbeitungsbereich, wobei jeder Input/Outputeine Sammlung von Werten ist. Die Pfeile, die in den Mengenverarbeitungsbereich hinein oderdaraus heraus weisen , legen die jeweilige Art des Erweiterungsknotens fest.
UnterbrechungsbereichEin Unterbrechungsbereich enthält Aktivitätsknoten. Wenn ein Kontrollfluss einenUnterbrechungsbereich 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 zueiner anderen Aktion enthält:
208 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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.
9.1.2 Zustandsdiagramm
Altova Website: UML-Zustandsdiagramme
Im Zustandsdiagramm wird das Verhalten eines Systems modelliert, indem die Zustände, indenen sich ein Objekt befinden kann und die Übergänge zwischen diesen Zuständen, beschriebenwerden. Im Allgemeinen dienen diese Diagramme dazu, das Verhalten eines Objekts inverschiedenen 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 unterbrochenwerden 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 andauerndeProzesse, die durch andere Ereignisse unterbrochen werden können, z.B. das Warten aufVerbindungsaufbauanfragen.
Beachten Sie, dass die in den folgenden Abschnitten gezeigten Zustandsdiagramme im UModelOrdner ...\UModelExamples im Beispiel Bank_MultiLanguage zur Verfügung stehen.
© 2017 Altova GmbH
Verhaltensdiagramme 209UML-Diagramme
Altova UModel 2017
Einfügen von Zustandsdiagrammelementen9.1.2.1
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 mehrereElemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt undklicken Sie in das Diagrammfenster.
Ziehen von bestehenden Elementen in das Zustandsdiagramm:Die meisten Elemente, die in anderen Zustandsdiagrammen vorkommen, können in einbestehendes Zustandsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register Modell-Struktur (Sie können dazu
210 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
das Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einem beliebigenElement zu suchen).
2. Ziehen Sie das/die Element(e) in das Zustandsdiagramm.
Erstellen von Zuständen, Aktivitäten und Transitionen9.1.2.2
So fügen Sie einen einfachen Zustand hinzu:
1. Klicken Sie in der Symbolleiste auf das Symbol Zustand ( ) und anschließend in dasDiagramm.
2. Geben Sie den Namen des Zustands ein und drücken Sie zur Bestätigung dieEingabetaste.
So fügen Sie eine Aktivität zu einem Zustand hinzu:
Rechtsklicken Sie auf das Element "Zustand", wählen Sie "Neu" und anschließend einender Einträge aus dem Kontextmenü.
Die Aktivitäten Eintritt, Austritt und Do sind mit einem der folgenden möglichen Verhaltenverknüpft: "Aktivität", "Interaktion" und "Zustandsautomat". Daher stehen im Kontextmenü diefolgenden Optionen zur Verfügung:
Austritt: AktivitätAustritt: InteraktionAustritt: ZustandsautomatDo: AktivitätDo: InteraktionDo: ZustandsautomatEintritt: AktivitätEintritt: InteraktionEintritt: Zustandsautomat
© 2017 Altova GmbH
Verhaltensdiagramme 211UML-Diagramme
Altova UModel 2017
Diese Optionen stammen aus der UML-Spezifikation. Bei jeder dieser internen Aktionen handeltes sich um ein Verhalten und in der UML-Spezifikation sind drei Klassen von der Klasse"Behavior" (Verhalten) abgeleitet: Activity (Aktivität), StateMachine (Zustandsautomat) undInteraction (Interaktion). Es macht im generierten Code keinen Unterschied, welches spezifischeVerhalten (Aktivität, Zustandsautomat oder Interaktion) ausgewählt wurde.
Sie haben die Wahl zwischen Aktionen aus der Kategorie: Eintritts, Austritt und Do. Aktivitätenwerden 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).
So löschen Sie eine Aktivität:
Klicken Sie auf die entsprechende Aktivität im Zustandselement und drücken Sie dieEntf-Taste.
So erstellen Sie eine Transition zwischen zwei Zuständen:
1. Klicken Sie auf den Transition-Ziehpunkt des Ausgangszustands (auf der rechten Seitedes 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 derTransition definieren: extern, intern oder lokal.
212 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Transitionen können einen Event Trigger, eine Guard-Bedingung und eine Aktion in derForm 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 entsprechendeOperation in der referenzierten Klasse automatisch erstellt, wenn Sie eine Transition erstellen undeinen Namen,z. B. myOperation() eingeben.
Anmerkung: Operationen können nur dann automatisch erstellt werden, wenn sich derZustandsautomat 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 dieentsprechende 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.
© 2017 Altova GmbH
Verhaltensdiagramme 213UML-Diagramme
Altova UModel 2017
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 AirConditionControllerhinzugefügt wurde.
Bitte beachten Sie:Operationen werden automatisch für: Do:Aktivität, Eintritt:Aktivität, Austritt:Aktivität sowieals 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. DenTriggern werden Standardwerte in der Form: Buchstabe des Alphabets, Ausgangszustand-> Zielzustand zugewiesen.
3. Doppelklicken Sie auf den neuen Buchstaben und geben Sie die Eigenschaften derTransition in der Form eventTrigger [Guard-Bedingung] /Aktivität ein.
214 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 demSchrägstrich folgt die Aktivität. Bei Bearbeitung des Strings werden automatisch dieentsprechenden Elemente in der Modell-Struktur erstellt bzw. gelöscht.
Bitte beachten Sie:Um die Eigenschaften der einzelnen Transition zu sehen, rechtsklicken Sie auf dieTransition (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 derausgewählten Transition angezeigt.
Hinzufügen eines Aktivitätsdiagramms zu einer Transition:
UModel bietet die einzigartige Möglichkeit, zur näheren Beschreibung der Transition einAktivitä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 dasDiagramm eingefügt.
2. Klicken Sie auf das eingefügte Fenster, um es aktiv zu machen. Über die Bildlaufleistenkönnen Sie durch das Fenster scrollen.
3. Doppelklicken Sie auf das Aktionsfenster um in das Aktivitätsdiagramm zu wechseln unddie Transition näher zu definieren, z.B. um den Namen der Aktion in "Database logon" zuändern.
© 2017 Altova GmbH
Verhaltensdiagramme 215UML-Diagramme
Altova UModel 2017
Beachten Sie, dass ein neues Aktivitätsdiagrammregister zum Projekt hinzugefügt wurde.Sie können jedes beliebige Aktivitätsdiagramm-Modellelement zum Diagrammhinzufügen. Nähere Informationen dazu finden Sie unter "Aktivitätsdiagramm".
4. Klicken Sie auf das Zustandsdiagrammregister um zurückzuwechseln und dieaktualisierte Transition zu sehen.
5. Ziehen Sie gegebenenfalls das Aktivitätsfenster an die gewünschte Stelle im Diagrammund klicken Sie auf den Ziehpunkt zur Größenanpassung.
216 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Wenn Sie das Aktivitätsfenster zwischen die beiden Zustände ziehen, wird die Transitionin die Aktivität und aus der Aktivität heraus angezeigt.
Zusammengesetzte Zustände9.1.2.3
Zusammengesetzter ZustandDiese 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 durchstrichlierte 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
© 2017 Altova GmbH
Verhaltensdiagramme 217UML-Diagramme
Altova UModel 2017
einem zusammengesetzten Zustand; sobald die letzte Region eines zusammengesetztenZustands gelöscht wurde, wird dieser wieder zu einem einfachen Zustand.
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. Daseingefügte Element ist nun Teil der Region und wird im Fenster "Modell-Struktur" alsChild-Element der Region angezeigt.
Wenn Sie den zusammengesetzten Zustand verschieben, werden alle darin enthaltenenZustä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 inZustandselementen anzeigen" und wählen Sie true/false aus.
UnterautomatenzustandDieser Zustand dient zum Ausblenden der Einzelheiten eines Zustandsautomaten. Dieser Zustandhat keine Regionen, sondern ist mit einem separaten Zustandsautomaten verknüpft.
218 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
So definieren Sie einen Unterautomatenzustand: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 Siedarauf 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 undklicken 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 "Eintritthinzufügen". Bitte beachten Sie, dass es an einer anderen Stelle im Diagramm einenweiteren Eintritts- oder Austrittspunkt geben muss, damit dieses Popup-Menü aktiviertwird.
© 2017 Altova GmbH
Verhaltensdiagramme 219UML-Diagramme
Altova UModel 2017
Daraufhin wird eine Eintrittspunktzeile zum Register "Eigenschaften" hinzugefügt und dasAussehen des Verbindungspunktreferenz-Elements ändert sich.
3. Fügen Sie auf dieselbe Weise einen Austrittspunkt hinzu. Wählen Sie dazu imKontextmenü den Befehl "Austritt hinzufügen".
Codegenerierung anhand von Zustandsdiagrammen9.1.2.4
Sie können in UModel nun ausführbaren Code (Java, VB.NET oder C#) anhand vonZustandsdiagrammen generieren. Es werden beinahe alle Zustandsdiagrammelemente und -funktionen unterstützt:
ZustandZusammengesetzter Zustand, mit jeder hierarchischen EbeneOrthogonaler Zustand, mit beliebig vielen RegionenRegionAnfangszustandEndzustandTransitionGuardTriggerAufrufereignisGabelungVereinigungEntscheidungKreuzungDeepHistoryShallowHistory
220 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Eintritts-/Austritts-/Do-AktionEffekt
Die Generierung von Zustandsautomatencode ist in das normale Round Trip Engineering integriert,d.h. der Zustandsautomatencode kann bei jedem Forward Engineering automatisch aktualisiertwerden.
In der Abbildung oben sehen Sie das Zustandsdiagramm AirCondition aus dem Verzeichnis ..\StateMachineCodeGeneration unter...\UModelExamples. Für jede der Sprachen, in der inUModel 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, diejeweils das entsprechende UModel-Projekt, die Programmiersprachen-Projektdateien sowie diegenerierten Quelldateien enthalten. Die Projektdatei Complex.ump enthält beinahe alle der vonUModel beim Generieren von Zustandsdiagrammcode unterstützten Modellierungselemente undFunktionalitä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.
© 2017 Altova GmbH
Verhaltensdiagramme 221UML-Diagramme
Altova UModel 2017
So generieren Sie anhand eines Zustandsdiagramms Code:Klicken Sie mit der rechten Maustaste in das Zustandsdiagramm und wählen Sie denBefehl "Zustandsautomatencode generieren" oderWählen Sie die Menüoption Projekt | Zustandsautomatencode generieren.
In der Abbildung oben sehen Sie die Standardeinstellungen. Klicken Sie zurCodegenerierung auf OK.
222 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Der Zustandsautomatencode wird automatisch aktualisiert, wenn Sie das Forward Engineeringstarten. Sie können diese Einstellung allerdings ändern, indem Sie auf den Hintergrund desZustandsdiagramms 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 klicken, wird dasDialogfeld "Zustandsautomatencode generieren" geöffnet, wo Sie dieCodegenerierungseinstellungen ändern können.
Bitte beachten Sie:Um in einem Zustandsdiagramm eine Syntaxüberprüfung durchzuführen, klicken Sie mitder rechten Maustaste auf das Diagramm und wählen Sie den Befehl
Zustandsautomatensyntax überprüfen.
Arbeiten mit Zustandsdiagrammcode9.1.2.5
Die übergeordnete Klasse des Zustandsdiagramms (d.h. die "Controller-Klasse" oder"Kontextklasse") bildet die einzige Schnittstelle zwischen dem Benutzer des Zustandsdiagrammsund der Zustandsdiagrammimplementierung.
Die Controller-Klasse bietet Methoden, mit Hilfe derer die Zustandsdiagramme von "außen" hergeä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. (sieheauch Erstellen von Zuständen, Aktivitäten und Transitionen). Diese Methoden können in UModelbeliebig (durch Hinzufügen von Parametern, Definieren der Parameter als abstrakt, usw.) geändertwerden.
Ein Zustandsdiagramm (d.h. seine Controller-Klasse) kann mehrmals instantiiert werden. AlleInstanzen sind unabhängig voneinander.
Die Ausführung des UML-Zustandsdiagramms ist für das Modell: Bis zur Fertigstellungen
© 2017 Altova GmbH
Verhaltensdiagramme 223UML-Diagramme
Altova UModel 2017
ausführen" konzipiert. UML-Zustandsautomaten gehen davon aus, dass jedes Ereignis abgeschlossen ist, bevordas nächste verarbeitet wird.Dies bedeutet auch, dass keine Entry/Exit/Do-Aktion oder kein Transitionseffekt eineneue 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 Zustandsdiagrammsautomatisch (oder bei Aufruf der Initialize()-Methode der Controller-Klasse).Wenn OnEntry-Ereignisse bei der Initialisierung nicht erwünscht sind, können Sie dieInitialize()-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. esgibt nicht nur einen aktuellen Zustand, sondern jede Region (auf jeder hierarchischen Ebene) kanneinen aktuellen Zustand haben.
Im Beispiel "AirCondition" wird gezeigt, wie die Regionen des aktuellen Zustands / der aktuellenZustände durchlaufen werden.
TreeNode rootNode = m_CurrentStateTree.Nodes.Add(m_STM.getRootState().getName());UpdateCurrentStateTree(m_STM.getRootState(), rootNode);
private void UpdateCurrentStateTree(AirCondition.AirConditionController.IStatestate, 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
224 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
{ … 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 Ereigniseine Zustandsänderung verursacht hat (d.h. ob es eine Auswirkung auf dasZustandsdiagramm 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 amZustandsdiagramm und MyEvent1() gibt "false" zurück.
Beispiel 2 - eine einfache Transition mit einem Effekt
Die entsprechende Operation wird in UModel automatisch generiert.
Generierte Methode im Code:private class CTestStateMachine : IState{ … // Override to handle entry/exit/do actions, transition effects,...: public virtual void OnState1State2Effect() {}}
"OnState1State2Effect()" wird immer dann von der Zustandsdiagrammimplementierungaufgerufen, wenn die Transition zwischen "State1" und "State2" ausgelöst wird.Als Reaktion auf diesen Effekt sollte "OnState1State2Effect()" in einer abgeleitetenKlasse von "CTestStateMachine" außer Kraft gesetzt werden."CTestStateMachine:: OnState1State2Effect()" kann auch auf "abstract" gesetzt werdenund Sie erhalten Kompilierfehler bis die Methode außer Kraft gesetzt wird.Wenn "OnState1State2Effect()" nicht "abstract" ist und die Option "Debug-Meldungen
© 2017 Altova GmbH
Verhaltensdiagramme 225UML-Diagramme
Altova UModel 2017
generieren" aktiv ist, generiert UModel die folgende Debug-Ausgabe:
// Override to handle entry/exit/do actions, transitioneffects,...:public virtual void OnState1State2Effect(){OnDebugMessage("ACTION: OnState1State2Effect");}
Beispiel 3 - eine einfache Transition mit einem Effekt-Parameter
Die entsprechende Operation wird in UModel automatisch generiert.
Generierte Methode im Code:private class CTestStateMachine : IState{ … // Additional defined operations of the controller class: public virtual void OnState1State2Effect(String text) { }}
Zur Durchführung von (automatisch mit UModel erzeugten) Operationen könnenParameter manuell hinzugefügt werden (UModel kann nicht wissen, welcher Typ benötigtwird).
In diesem Beispiel wurde der Parameter "text:String" zur Effekt-Methode in TestControllerhinzugefügt. Beim Aufruf dieser Methode muss ein ordnungsgemäßes Argument definiertwerden (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:
226 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Die entsprechenden Operationen werden in UModel automatisch generiert.
Generierte Methode im Code:private class CTestStateMachine : IState{ … // 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 dieentsprechenden 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 Folgeaufgerufen werden. Anschließend würden "OnEntryState4" und "OnDoState4" aufgerufenwerden.Normalerweise sollten diese Methoden außer Kraft gesetzt werden. Wenn sie nichtabstrakt sind und die Option "Debug-Meldungen generieren" aktiv ist, liefert UModel eineStandard-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 wirklichausgelöst werden kann.
© 2017 Altova GmbH
Verhaltensdiagramme 227UML-Diagramme
Altova UModel 2017
Die entsprechende Operation wird in UModel automatisch generiert.
Generierte Methode im Code:private class CTestStateMachine : IState{ … // 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 dieZustandsdiagrammimplementierung "CanGoState6" auf und je nach Ergebnis wird dieTransition ausgelöst oder nicht.Normalerweise sollten diese Methoden außer Kraft gesetzt werden. Wenn sie nichtabstrakt sind und die Option "Debug-Meldungen generieren" aktiv ist, liefert UModel eineStandard-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 Guardsmöglich. Die Reihenfolge, in der die verschiedenen Guards abgefragt werden, ist nichtdefiniert. Wenn eine Transition keinen Guard hat oder der Guard "else" ist, wird sie alsder letzte Guard betrachtet (d.h. dieser Guard wird nur dann ausgelöst, wenn alle anderenTransitions-Guards "false" zurückgeben). So ist z.B. im Diagramm unten nicht definiert,ob CanGoState6() oder CanGoState7() zuerst aufgerufen wird. Die dritte Transition wirdnur ausgelöst, wenn CanGoState6() und CanGoState7() false zurückgeben.
Weitere Konstrukte und Funktionalitäten finden Sie in den Beispielen AirCondition.ump undComplex.ump.
228 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Zustandsdiagramm-Elemente9.1.2.6
Startzustand (Pseudozustand)Der Beginn eines Prozesses.
EndzustandDas 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.
EntscheidungDieses Element stellt eine dynamische bedingte Verzweigung dar, wobei einander gegenseitigausschließ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.Dient zum Aufteilen von Sequenzen in nebenläufige Untersequenzen.
Vereinigung (Pseudozustand)Vereinigt/führt zuvor definierte Untersequenzen zusammen. Alle Aktivitäten müssenabgeschlossen sein, bevor Sie fortfahren können.
Vereinigung, horizontal (Pseudozustand)Vereinigt/führt zuvor definierte Untersequenzen zusammen. Alle Aktivitäten müssenabgeschlossen sein, bevor Sie fortfahren können.
© 2017 Altova GmbH
Verhaltensdiagramme 229UML-Diagramme
Altova UModel 2017
DeepHistoryEin Pseudozustand, der den zuvor aktiven Zustand in einem zusammengesetzten Zustandwiederherstellt.
ShallowHistoryEin Pseudozustand, der den Ausgangszustand eines zusammengesetzten Zustandswiederherstellt.
Alle Pseudozustandselemente können in einen anderen "Typ" geändert werden, indem Sie aufdem Register "Eigenschaften" den Eintrag in der Auswahlliste "Art" ändern.
VerbindungspunktreferenzEine Verbindungspunktreferenz stellt eine Verwendung (als Teil eines Unterautomatenzustands)eines Eintritts-/Austrittspunkts dar, der in der Zustandsautomatenreferenz durch denUnterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:Der Zustand, mit dem der Punkt verbunden ist, muss selbst einenUnterautomatenzustand referenzieren. (sichtbar auf dem Register "Eigenschaften").Dieser Unterautomat muss einen oder mehrere Eintritts- oder Austrittspunkte enthalten.
TransitionEine direkte Beziehung zwischen zwei Zuständen. Ein Objekt im ersten Zustand führt eine odermehrere Aktionen durch und tritt anschließend abhängig von einem Ereignis und der Erfüllungetwaiger Guard-Bedingungen in den zweiten Zustand ein.
Transitionen haben einen Event-Trigger, (eine) Guard-Bedingung(en), eine Aktion (Verhalten) undeinen Zielzustand.
Unterstützte Ereignisunterelemente sind:
ReceiveSignalEvent, SignalEvent, SendSignalEvent, ReceiveOperationEvent,SendOperationEvent und ChangeEvent.
230 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Automatische Erstellung von Operationen in der Zielkomponente durch Eingabe vonOperationsnamen ein-/ausschalten
Wenn Sie die Schaltfläche "Automatische Erstellung von Operationen in der Zielkomponentedurch Eingabe von Operationsnamen ein-/ausschalten" aktivieren, wird die entsprechendeOperation in der referenzierten Klasse automatisch erstellt, wenn Sie eine Transition erstellen undeinen Namen myOperation() eingeben.
Anmerkung: Operationen können nur dann automatisch erstellt werden, wenn sich derZustandsautomat innerhalb einer Klasse oder Schnittstelle befindet.
9.1.3 Protokoll-Zustandsautomat
Altova Website: UML-Protokoll-Zustandsdiagramme
Mit Hilfe von Protokoll-Zustandsautomaten wird eine Sequenz von Ereignissen dargestellt, auf dieein Objekt reagiert, ohne dass das spezifische Verhalten dargestellt werden muss. In diesemDiagramm werden die benötigte Ereignissequenz und die resultierenden Änderungen am Zustanddes Objekts modelliert.
Meist dienen Protokoll-Zustandsautomaten zur Beschreibung komplexer Protokolle, z.B. zurBeschreibung des Datenbankzugriffs über eine bestimmte Schnittstelle oder vonKommunikationsprotokollen wie TCP/IP.
Protokoll-Zustandsautomaten werden auf dieselbe Weise wie Zustandsdiagramme erstellt, habenaber weniger Modellierungselemente. Die Protokoll-Übergänge zwischen Zuständen können Vor-und 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.
© 2017 Altova GmbH
Verhaltensdiagramme 231UML-Diagramme
Altova UModel 2017
Einfügen von Protokoll-Zustandsdiagramm-Elementen9.1.3.1
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. Ummehrere Elemente des ausgewählten Typs einzufügen, halten Sie die Strg-Tastegedrü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 einbestehendes Diagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register Modell-Struktur (Sie können dazudas Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einem beliebigenElement zu suchen).
2. Ziehen Sie das/die Element(e) in das Protokoll-Zustandsdiagramm.
232 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
So fügen Sie einen einfachen Zustand ein:
1. Klicken Sie in der Symbolleiste auf das Zustandssymbol und anschließend in dasProtokoll-Zustandsdiagramm, um es einzufügen.
2. Geben Sie den Namen des Zustands ein und drücken Sie zur Bestätigung dieEingabetaste.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 "ProtocolTransition".
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 Nachbedingungeingeben können. Verwenden Sie unbedingt die eckigen Klammern [] und denSchrägstrich, wenn Sie die Bedingungen direkt eingeben.
Wenn Sie die Vor-/Nachbedingung im Fenster "Eigenschaften" eingeben, werden dieeckigen Klammern und der Schrägstrich automatisch in das Diagramm eingefügt.
So erstellen Sie Elemente zusammengesetzter Zustände und Unterautomatenzuständebzw. fügen diese ein:
Siehe Zusammengesetzte Zustände
Protokoll-Zustandsdiagramm-Elemente9.1.3.2
ZustandEin einfaches Zustandselement mit nur einem Bereich.
Zusammengesetzter ZustandDiese Art von Zustand enthält einen zweiten Bereich bestehend aus einer einzigen Region.
© 2017 Altova GmbH
Verhaltensdiagramme 233UML-Diagramme
Altova UModel 2017
Innerhalb dieser Region können beliebig viele Zustände platziert werden.
Orthogonaler ZustandDiese Art von Zustand enthält einen zweiten Bereich bestehend aus zwei oder mehrerenRegionen, wobei separate Regionen Gleichzeitigkeit kennzeichnen.
Wenn Sie mit der rechten Maustaste auf einen Zustand klicken und den Befehl Neu | Regionauswählen, können Sie neue Regionen hinzufügen.
UnterautomatenzustandMit 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.
EndzustandDas 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.
EntscheidungDieses Element stellt eine dynamische bedingte Verzweigung dar, wobei einander gegenseitigausschließ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.Dient zum Aufteilen von Sequenzen in nebenläufige Untersequenzen
234 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Vereinigung (Pseudozustand)Vereinigt/führt zuvor definierte Untersequenzen zusammen. Alle Aktivitäten müssenabgeschlossen sein, bevor Sie fortfahren können.
Vereinigung, horizontal (Pseudozustand)Vereinigt/führt zuvor definierte Untersequenzen zusammen. Alle Aktivitäten müssenabgeschlossen sein, bevor Sie fortfahren können.
VerbindungspunktreferenzEine Verbindungspunktreferenz stellt eine Verwendung (als Teil eines Unterautomatenzustands)eines Eintritts-/Austrittspunkts dar, der in der Zustandsautomatenreferenz durch denUnterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:Der Zustand, mit dem der Punkt verbunden ist, muss selbst einenUnterautomatenzustand referenzieren. (sichtbar auf dem Register "Eigenschaften").Dieser Unterautomat muss einen oder mehrere Eintritts- oder Austrittspunkte enthalten.
Protocol TransitionEine direkte Beziehung zwischen zwei Zuständen. Ein Objekt im ersten Zustand führt eine odermehrere Aktionen durch und tritt anschließend abhängig von einem Ereignis und der Erfüllungetwaiger Vor- oder Nachbedingungen in den zweiten Zustand ein.
Nähere Informationen dazu finden Sie unter Einfügen von Protokoll-Zustandselementen.
9.1.4 Use Case-Diagramm
Eine Anleitung zum Hinzufügen von Klassen zum Diagramm finden Sie im Tutorial im Abschnitt Use Cases.
© 2017 Altova GmbH
Verhaltensdiagramme 235UML-Diagramme
Altova UModel 2017
9.1.5 Kommunikationsdiagramm
Altova Website: UML-Kommunikationsdiagramme
In Kommunikationsdiagrammen werden Interaktionen d.h. Nachrichtenflüsse zwischen Objektenzur Laufzeit und die Beziehungen zwischen den miteinander in Wechselbeziehung stehendenObjekten dargestellt. Im Grunde dienen diese Diagramme zum Modellieren des dynamischenVerhaltens von Anwendungsfällen (Use Cases).
Kommunikationsdiagramme weisen denselben Aufbau wie Sequenzdiagramme auf, mitAusnahme dessen, dass die Notation ein anderes Layout aufweist. Zur Kennzeichnung derReihenfolge der Nachrichten und der Schachtelung sind die Nachrichten nummeriert.
Sie können in UModel mit einer einzigen einfachen Aktion Kommunikationsdiagramme anhandvon Sequenzdiagrammen erstellen und umgekehrt. Nähere Informationen dazu finden Sie unter"Generieren von Sequenzdiagrammen".
236 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Einfügen von Kommunikationsdiagrammelementen9.1.5.1
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 mehrereElemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt undklicken Sie in das Diagrammfenster.
Ziehen vorhandener Elemente in das Kommunikationsdiagramm:Elemente, die in anderen Diagrammen vorkommen, z.B. Klassen, können in einKommunikationsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register Modell-Struktur (Sie können dazudas Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einem beliebigenElement zu suchen).
2. Ziehen Sie das/die Element(e) in das Kommunikationsdiagramm.
LebenslinieDas Element "Lebenslinie" ist Teil einer Interaktion mehrerer Elemente. Sie haben in UModel dieMö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/Schattierungder Lebenslinie über die "Farbverlauf Titel"-Auswahllisten auf dem Register "Stile" neu definieren.
Zur Erstellung einer Lebenslinie mit mehreren Zeilen, drücken Sie Strg + Eingabetaste, umeine 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.
© 2017 Altova GmbH
Verhaltensdiagramme 237UML-Diagramme
Altova UModel 2017
2. Geben Sie einen Namen für die Lebenslinie ein, um den Standardnamen "Lebenslinie1"bei Bedarf zu ändern.
NachrichtenEine Nachricht ist ein Modellierungselement, das eine bestimmte Art von Kommunikation in einerInteraktion 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 Nachrichtdefiniert den Absender und Empfänger und um welche Art von Kommunikation es sich handelt.
Nachricht (Aufruf) Nachricht (Antwort) Nachricht (Erstellung) Nachricht(Löschung)
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 Stellegezogen werden kann.
Anmerkung: Wenn Sie die Strg-Taste gedrückt halten, können Sie mit jedem Klick eineNachricht einfügen.
So fügen Sie weitere Nachrichten ein:1. Rechtsklicken Sie auf die vorhandene Kommunikationsverbindung und wählen Sie Neu |
Nachricht.
238 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 klickenund die Maus ziehen.
NachrichtennummerierungIn Kommunikationsdiagrammen wird die Nummerierung in Dezimalschreibweise verwendet,wodurch die hierarchische Struktur der Nachrichten im Diagramm klarer ersichtlich ist. Bei derReihenfolge handelt es sich um eine durch Punkte getrennte Liste von aufeinander folgendenZahlen, gefolgt von einem Doppelpunkt und dem Namen der Nachricht.
Generieren von Sequenzdiagrammen anhand vonKommunikationsdiagrammen:Sie können in UModel in einer einzigen Aktion Kommunikationsdiagramme anhand vonSequenzdiagrammen generieren und umgekehrt,
Rechtsklicken Sie an eine beliebige Stelle in einem Kommunikationsdiagramm und wählen Sieim Kontextmenü den Befehl Sequenzdiagramm generieren.
© 2017 Altova GmbH
Verhaltensdiagramme 239UML-Diagramme
Altova UModel 2017
9.1.6 Interaktionsübersichtsdiagramm
Altova Website: UML-Interaktionsübersichtsdiagramme
Interaktionsübersichtsdiagramme sind eine Variante von Aktivitätsdiagrammen und geben Ihneneinen Überblick über die Interaktion zwischen anderen Interaktionsdiagrammen wie z.B. Sequenz-, Aktivitäts, Kommunikations- oder Zeitverlaufsdiagrammen. Interaktionsübersichtsdiagrammewerden auf ähnliche Art wie Aktivitätsdiagramme und unter Verwendung derselbenModellierungselemente (Start-/Endpunkte, Gabelungen, Vereinigungen usw.) erstellt.
240 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Anstelle von Aktivitätselementen werden zwei Arten von Interaktionselementen verwendet: DieElemente "Interaktion" und "Interaktionsverwendung".
Sequenz-, Kommunikations-, Zeitverlaufs- oder Interaktionsübersichtsdiagramme werden alsElemente in Form grafischer Symbole innerhalb eines Rahmens dargestellt, in dessen linkeroberer Ecke das Schlüsselwort "SD" angezeigt wird.
Elemente für Interaktionsinstanzen sind Referenzen, die auf vorhandene Interaktionsdiagrammeverweisen, wobei im Titelbereich des Rahmens das Schlüsselwort "Ref" und innerhalb desRahmens der Name der Interaktionsinstanz angezeigt wird.
Einfügen von Interaktionsübersichtselementen9.1.6.1
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Interaktionsübersichtsdiagramm-Symbolleiste auf das entsprechende
Symbol
© 2017 Altova GmbH
Verhaltensdiagramme 241UML-Diagramme
Altova UModel 2017
2. Klicken Sie in das Diagramm, um das Element einzufügen. Um mehrere Elemente desausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt und klicken Sie indas Diagrammfenster.
Ziehen vorhandener Elemente in das Interaktionsübersichtsdiagramm:Elemente, die in anderen Diagrammen vorkommen, z.B. Sequenz-, Aktivitäts-, Kommunikations-oder Zeitverlaufsdiagramme, können in ein Interaktionsübersichtsdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register Modell-Struktur (Sie können dazudas Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einem beliebigenElement 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 ...\Examplesverwenden, wird das "Collect Account Information" Sequenzdiagramm automatischeingefügt. Standardmäßig wird das erste in der Modell-Struktur gefundeneSequenzdiagramm 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.
242 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 Interaktionselementals 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 ...
© 2017 Altova GmbH
Verhaltensdiagramme 243UML-Diagramme
Altova UModel 2017
\UModelExamples verwenden, wird das "Collect Account Information"Sequenzdiagramm automatisch als Interaktionselement eingefügt. Standardmäßig wirddas 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 Abbildungoben angezeigt werden, d.h. mit "ref" im Titelbereich des Rahmens.
VerzweigungsknotenFügt einen Verzweigungsknoten mit einer einzigen eingehenden Transition und mehreren mitGuards versehenen ausgehenden Transitionen ein. Nähere Informationen dazu finden Sie unter"Erstellen einer Verzweigung".
VerbindungsknotenFügt einen Verbindungsknoten ein, der mehrere alternative durch den Verzweigungsknotendefinierte Transitionen zusammenführt. Gleichzeitige Prozesse werden dabei von diesem Knotennicht synchronisiert, sondern es wird einer der Prozesse ausgewählt.
StartknotenDer Anfang eines Aktivitätsprozesses. Eine Interaktion kann mehrere Startknoten haben.
AktivitätsendknotenDas Ende des Interaktionsprozesses. Eine Interaktion kann mehrere Endknoten haben. AlleFlüsse werden gestoppt, wenn der "erste" Endknoten erreicht wird.
ParallelisierungsknotenFügt einen vertikalen Parallelisierungsknoten ein. Dient zum Teilen von Flüssen in mehrere parallele Flüsse.
Parallelisierungsknoten (horizontal)Fügt einen horizontalen Parallelisierungsknoten ein. Dient zum Teilen von Flüssen in mehrere parallele Flüsse.
244 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
SynchronisationsknotenFügt einen vertikalen Synchronisationsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknoten definierteFlüsse.
Synchronisationsknoten (horizontal)Fügt einen horizontalen Synchronisationsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknoten definierteFlüsse.
Zeitdauerbedingung hinzufügenEine Zeitdauer definiert eine Wertespezifikation, die eine Zeitdauer zwischen einem Start- undeinem Endpunkt angibt. Eine Zeitdauer ist oft ein Ausdruck, der die Anzahl der Uhrticks darstellt,die während dieser Dauer verstreichen.
KontrollflussEin Kontrollfluss ist eine Kante, d.h. eine mit einem Pfeil versehene Linie, die zwei Verhaltenverbindet und eine Interaktion startet, nachdem die vorherige zu Ende geführt wurde.
9.1.7 Sequenzdiagramm
Altova Website: UML-Sequenzdiagramme
UModel unterstützt das in UML definierte Standard-Sequenzdiagramm und ermöglicht dieeinfache Manipulation von Objekten in Objekten und Nachrichten zur Modellierung vonFallszenarios. Beachten Sie bitte, dass die in den folgenden Abschnitten gezeigtenSequenzdiagramme nur in den Beispieldateien Bank_Java.ump, Bank_CSharp.ump undBank_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.
© 2017 Altova GmbH
Verhaltensdiagramme 245UML-Diagramme
Altova UModel 2017
Einfügen von Sequenzdiagrammelementen9.1.7.1
In einem Sequenzdiagramm werden dynamische Laufzeit-Objektbeziehungen mit Hilfe vonNachrichten modelliert. Sequenzdiagramme dienen im Allgemeinen zur Verdeutlichung einzelnerUse Case-Szenarios.
Lebenslinien sind die horizontal angeordneten Kästchen am oberen Rand desDiagramms. Zusammen mit einer strichlierten vertikalen Linie stellen sie das Objekt undseine Interaktionen in einem zeitlichen Ablauf dar. Nachrichten werden in Form vonPfeilen zwischen den Lebenslinien von zwei oder mehr Objekten dargestellt.
246 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Nachrichten werden zwischen sendenden und empfangenden Objekten gesendet undals Pfeile mit einer Bezeichnung dargestellt. Nachrichten können eine Sequenznummerund verschiedene weitere optionale Attribute haben: argument list usw. Es werdenbedingte, optionale und alternative Nachrichten unterstützt. Nähere Informationen dazufinden Sie unter Combined Fragment .
Nähere Informationen finden Sie unter den folgenden Themen:LebenslinieCombined FragmentInteraction UseGateZustandsinvarianteNachrichten
Sequenzdiagramm- und andere UModel-Elemente können auf verschiedene Arten in einSequenzdiagramm eingefügt werden.
Ü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
Elemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt undklicken Sie in das Diagrammfenster.
© 2017 Altova GmbH
Verhaltensdiagramme 247UML-Diagramme
Altova UModel 2017
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.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (Sie könnendazu das Suchfunktionstextfeld verwenden oder Strg + F drücken).
2. Ziehen Sie das Element/die Elemente in das Sequenzdiagramm.
Lebenslinie9.1.7.1.1
Lebenslinie Eine Lebenslinie ist als einzelnes Element an einer Interaktion beteiligt. Sie haben in UModel dieMöglichkeit auch andere Elemente in das Sequenzdiagramm einzufügen, z.B. Klassen undAkteure. 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 Sequenzdiagrammsangezeigt. Die Beschriftungen können in der Leiste neu positioniert und in der Größe angepasstwerden, 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 demRegister "Stile" anpassen.
Zur Erstellung einer Lebenslinie mit mehreren Zeilen, drücken Sie Strg + Eingabetaste, umeine 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 Lebensliniefungiert. Wenn Sie Eigenschaften, deren Typ definiert ist, in ein Sequenzdiagramm ziehen, wirdebenfalls eine Lebenslinie erstellt.
Ausführungsspezifikation (Objektaktivierung):Eine Ausführungsspezifikation (Aktivierung) wird in Form eines Kästchens (Rechteck) auf derObjektlebenslinie dargestellt. Eine Aktivierung ist die Ausführung einer Prozedur und die Zeit, die
248 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
benötigt wird, um etwaige geschachtelte Prozeduren auszuführen. Aktivierungskästchen werdenautomatisch erstellt, wenn zwischen zwei Lebenslinien eine Nachricht erstellt wird.
Eine rekursive Nachricht oder Selbstnachricht (self message), also eine Nachricht, die eineandere 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 dieAktivierungskästchen im Sequenzdiagramm ein- und ausblenden.
Lebenslinienattribute:Über das Kontrollkästchen Löschung können Sie einen Lösch-Marker oder Stopp zur Lebensliniehinzufügen, ohne eine Löschnachricht verwenden zu müssen.
Über das Feld Selektor können Sie einen Ausdruck eingeben, der den durch die Lebensliniedargestellten Teil spezifiziert, wenn das Element, das verbunden werden kann, mehrere Wertehat, d.h. eine Multiplizität größer als eins aufweist.
Gehe zu LebenslinienelementWenn Sie mit der rechten Maustaste auf eine Lebenslinie klicken, können Sie die Option "Gehezu XXX" auswählen, wobei XXX für den Typ der speziellen Lebenslinie steht, auf die Sie geklickthaben. Das Element wird daraufhin im Fenster "Model-Struktur" angezeigt.
Combined Fragment9.1.7.1.2
Combined FragmentCombined Fragments sind Untereinheiten oder Abschnitte einer Interaktion. DerInteraktionsoperator, der im Fünfeck in der linken oberen Ecke angezeigt wird, definiert, umwelche spezifische Art von Combined Fragment es sich handelt. Die Einschränkung definiertdaher das jeweilige Fragment z.B. loop fragment, alternative fragment usw., welches in derInteraktion verwendet wird.
© 2017 Altova GmbH
Verhaltensdiagramme 249UML-Diagramme
Altova UModel 2017
Über die Symbole für Combined Fragments in der Symbolleiste können Sie bestimmte CombinedFragments einfügen: seq, alt oder loop. Auch durch Klicken auf die Interaktionsoperator-Auswahlliste können Sie das spezifische Interaktionsfragment definieren.
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.
250 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Wenn in einem der Operanden der Guard-Ausdruck "else" verwendet wird, wird dieser Operandausgeführt, wenn alle anderen Guards den Wert "false" zurückgeben. Die Guard-Expression kannunmittelbar beim Einfügen eingegeben werden und wird innerhalb der beiden eckigen Klammernangezeigt.
Bei der Interaktionsbedingung handelt es sich eigentlich um den Guard-Ausdruck zwischenden eckigen Klammern.
Option opt Option steht für eine Auswahl, wobei entweder nur der Operand ausgeführt wird oder nichtspassiert.
Abbruchfragment breakDer Break-Operator wird ausgewählt, wenn Guard "true" ist. Der Rest des umschließendenFragments wird ignoriert.
Parallel parZeigt an, dass das Combined Fragment eine parallele Zusammenführung von Operanden darstellt.
Strenge Ordnung strictDas Combined Fragment stellt eine strenge Ordnung zwischen dem Verhalten der Operandendar.
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 Schleifen-Fünfeck) direkt bearbeiten, indem Sie darauf doppelklicken.
Kritischer Bereich criticalDas Combined Fragment stellt einen kritischen Bereich dar. Die Sequenz(en) darf/dürfen nicht
© 2017 Altova GmbH
Verhaltensdiagramme 251UML-Diagramme
Altova UModel 2017
durch andere Prozesse unterbrochen werden.
Negativ negDefiniert, dass das Fragment ungültig ist und dass alle anderen als gültig gelten.
Sicherstellung assertKennzeichnet das gültige Combined Fragment und seine Sequenzen. Wird oft in Kombination mitconsider- oder ignore-Operanden verwendet.
Ignore ignoreDefiniert, welche Nachricht in der Interaktion ignoriert werden soll. Wird oft im Zusammenhang mit"Sicherstellung" oder "Consider"-Operanden verwendet.
Consider considerDefiniert, 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 GuardCondition eingeben können.
2. Geben Sie die Guard Condition für den Interaktionsoperanden ein, z.B. !passwordOKund bestätigen Sie mit der Eingabetaste.
Mit Strg + Eingabetaste können Sie einen mehrzeiligen Interaktionsoperandenerstellen.
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:1. Doppelklicken Sie im Diagramm (nicht auf dem Register "Eigenschaften") auf die Guard-
Expression 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 CombinedFragment wird automatisch angepasst.
252 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Interaction Use9.1.7.1.3
Interaction UseDas Element "Interaction Use" ist eine Referenz auf ein Interaktionselement. Mit Hilfe diesesElements können Sie Abschnitte einer Interaktion mit verschiedenen anderen Interaktionengemeinsam verwenden.
Wenn Sie auf die Auswahlliste "referenziert" klicken, können Sie die Interaktion auswählen, aufdie Sie referenzieren möchten. Der Name der ausgewählten Interaktion wird im Elementangezeigt.
Bitte beachten Sie:Sie können auch ein vorhandenes Interaction Use-Element aus der Modell-Struktur insDiagrammfenster ziehen.
Gate9.1.7.1.4
GateEin 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 Gatedarstellt, wird nun kleiner angezeigt.
© 2017 Altova GmbH
Verhaltensdiagramme 253UML-Diagramme
Altova UModel 2017
Zustandsinvariante9.1.7.1.5
ZustandsinvarianteEine Zustandsinvariante ist eine Bedingung oder eine Einschränkung, die auf eine Lebenslinieangewendet 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.
Nachrichten9.1.7.1.6
Nachrichten werden von sendenden an empfangende Lebenslinien gesendet und in Formbeschrifteter Pfeile angezeigt. Nachrichten können eine Sequenznummer und verschiedeneandere optionale Attribute aufweisen: argument list usw. Nachrichten werden von oben nach untenangezeigt, d.h. die vertikale Linie stellt den zeitlichen Ablauf im Sequenzdiagramm dar.
Ein Aufruf ist eine synchrone oder asynchrone Kommunikation, die eine Operationaufruft, über die die Kontrolle zum sendenden Objekt zurückkehren kann. Ein Aufrufpfeilzeigt 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).
254 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
So fügen Sie eine Nachricht ein:1. Klicken Sie in der Sequenzdiagramm-Symbolleiste auf das jeweilige Nachrichtensymbol. 2. Klicken Sie auf die Lebenslinie oder das Aktivierungskästchen des Sender-Objekts. 3. Ziehen Sie die Nachrichtenlinie auf die Lebenslinie oder das Aktivierungskästchen des
Empfängerobjekts. Objektlebenslinien erscheinen markiert, wenn Sie die Nachrichtdorthin ziehen können.
Die Richtung, in die Sie die Pfeile ziehen, bestimmt die Richtung der Nachricht.Antwortnachrichten können in jede der beiden Richtungen weisen.
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 auchmanuell durch Ziehen der entsprechenden Ziehpunkte anpassen.
Abhängig davon, welche Einstellungen Sie für die Nummerierung der Nachrichten aktivierthaben, wird die Nummerierungsreihenfolge aktualisiert.
Wenn Sie auf ein Nachrichtensymbol klicken und dabei die Strg-Taste gedrückt halten,können Sie mehrere Nachrichten einfügen. Ziehen Sie dazu einfach mehrere Nachrichtenin 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 verbleibendenObjekte werden aktualisiert.
"Gehe zu-Operation" für Call-Nachrichten:Die durch Call-Nachrichten referenzierten Operationen werden in Sequenz- undKommunikationsdiagrammen verwendet.
1. Rechtsklicken Sie auf eine Call-Nachricht und wählen Sie den Option "Gehe zuOperation".
© 2017 Altova GmbH
Verhaltensdiagramme 255UML-Diagramme
Altova UModel 2017
Die Anzeige ändert sich und die die Verbindungsoperation wird auf dem Register "Modell-Struktur" angezeigt.
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 Nachrichtalle mit der aktiven in Zusammenhang stehenden Nachrichten mitverschoben.
256 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 aneiner beliebigen Stelle auf der vertikalen Achse zwischen den Objektlebenslinienpositionieren.
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, einfachund keine.
Keine 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 Strukturder Nachrichten im Diagramm deutlich wird. Die Hierarchie wird in Form einer durchPunkte getrennten Nummerierung, gefolgt von einem Doppelpunkt und dem Namen derNachricht 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
© 2017 Altova GmbH
Verhaltensdiagramme 257UML-Diagramme
Altova UModel 2017
Nummerierungssystem nicht immer alle Nachrichten richtig nummeriert. Fügen Sie indiesem Fall Antwortnachrichten hinzu, um Unklarheiten zu beseitigen.
Antwortnachrichten:Zum Erstellen von Antwortnachrichten stehen Nachrichtenantwortsymbole zur Verfügung. Diesewerden als strichlierte Pfeile dargestellt.
Im Allgemeinen geht es außerdem aus dem unteren Bereich der Aktivierungskästchen - fallsdiese aktiviert sind - hervor, ob Antwortnachrichten erwartet werden. Wenn Aktivierungskästchendeaktiviert 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/
aus" aktivieren, wird automatisch eine syntaktisch korrekte Antwortnachricht erstellt, wenn Sieeine 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 undpositioniert das Objektkästchen oft in vertikaler Richtung neu.
Senden von Nachrichten an bestimmte Klassenmethoden/-operationen inSequenzdiagrammenNachdem Sie eine Klasse aus der Modellstruktur in ein Sequenzdiagramm eingefügt haben,können Sie anschließend mit Hilfe der UModel Syntaxhilfe und der Autokomplettierungsfunktioneneine Nachricht von einer Lebenslinie zu einer bestimmten Methode der Empfängerklasse(Lebenslinie) erstellen.
1. Erstellen Sie eine Nachricht zwischen zwei Lebenslinien, wobei es sich beimEmpfängerobjekt um eine Klassenlebenslinie (Bank) handeln muss.Nachdem Sie denNachrichtenpfeil gezogen haben, erscheint der Name der Nachricht automatischmarkiert.
2. Geben Sie über die Tastatur ein Zeichen ein, z.B. "b". Es erscheint ein Popup-Fenster
258 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
mit einer Liste der verfügbaren Klassenmethoden.
3. Wählen Sie eine Operation aus der Liste aus, z.B. collectAccountinfos und drücken Siedie Eingabetaste.
4. Drücken Sie die Leertaste und anschließend die Eingabetaste, um das automatischvorgegebene Klammerzeichen auszuwählen.Es erscheint ein Syntaxhilfefenster, über das Sie den Parameter korrekt eingebenkönnen.
Erstellen von Operationen in referenzierten KlassenWenn Sie die Schaltfläche "Automatische Erstellung von Operationen in der Zielkomponente
durch Eingabe von Operationsnamen ein-/ausschalten" aktivieren, wird die entsprechendeOperation in der referenzierten Klasse automatisch erstellt, wenn Sie eine Transition erstellen undeinen Namen myOperation() eingeben.
Anmerkung: Operationen können nur dann automatisch erstellt werden, wenn sich derZustandsautomat innerhalb einer Klasse oder Schnittstelle befindet.
Nachrichtensymbole:
© 2017 Altova GmbH
Verhaltensdiagramme 259UML-Diagramme
Altova UModel 2017
Nachricht (Aufruf)
Nachricht (Antwort)
Nachricht (Erstellung)
Nachricht (Löschung)
Asynchrone Nachricht (Aufruf)
Asynchrone Nachricht (Antwort)
Asynchrone Nachricht (Löschung)
Verschieben zusammengehöriger Nachrichten ein/aus
Automatische Erstellung von Antworten auf Nachrichten (Call) ein/aus
Automatische Erstellung von Operationen in der Zielkomponente durch Eingabe vonOperationsnamen ein-/ausschalten
Generieren von Sequenzdiagrammen anhand von Quellcode9.1.7.2
Sie können in UModel nun Sequenzdiagramme direkt anhand von Code erstellen. .
Im Beispiel unten sehen Sie, wie man automatisch ein Sequenzdiagramm unter Verwendungeiner bestehenden Methode erstellt. Sie können auf diese Weise natürlich auch anhand Ihreseigenen Codes ein Sequenzdiagramm erstellen. Die Methode steht im OrgChart-Paket zurVerfügung, welches im Tutorial mit dem Befehl Projekt | Quellverzeichnis importierenimportiert wurde. Nähere Informationen zum Importieren von Code finden Sie im Tutorial unterRound-Trip Engineering (Code - Modell - Code).
1. Klicken Sie, nachdem Sie den Code importiert haben, in der Modellstruktur mit derrechten Maustaste auf die main Methode der Klasse OrgChartTest und wählen Sie denBefehl "Sequenzdiagramm generieren..."
260 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung", angezeigt, in dem Sie dieEinstellungen dazu definieren können.
2. Wählen Sie die gewünschten Darstellungs- und Layout-Optionen aus und klicken Sieanschließend auf OK, um das Diagramm zu generieren.Mit den oben gewählten Einstellungen wird das unten gezeigte Sequenzdiagrammerzeugt.
© 2017 Altova GmbH
Verhaltensdiagramme 261UML-Diagramme
Altova UModel 2017
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 vonTypen definieren, die im Sequenzdiagramm nicht aufscheinen sollen, wenn es generiertwird.
Mit der Option "Zu ignorierende Operationsnamen" können Sie eine kommagetrennteListe von Operationen definieren, die im generierten Sequenzdiagramm nicht aufscheinensollen (initComponents werden standardmäßig automatisch hinzugefügt).
Wenn Sie die Operationsnamen, z.B. "InitComponents", zur Liste hinzufügen, wird diekomplette Operation ignoriert. Wenn Sie der Operation in der Liste ein + (Pluszeichen)voranstellen, z.B. +InitComponent, werden die Operationsaufrufe im Diagrammangezeigt, jedoch ohne Inhalt.
Mit der Option "In kleinere Diagramme aufteilen, wo angebracht" werdenSequenzdiagramme in kleinere Subdiagramme aufgeteilt, zwischen denen zureinfacheren Navigation automatisch Hyperlinks angelegt werden.
Sequenzdiagramme werden automatisch aktualisiert, wenn Sie das komplette UModel-Projekt
262 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
aktualisieren. Sequenzdiagramme werden nicht aktualisiert, wenn Sie Klassen oder einzelneDateien extern aktualisieren. Sie können die Einstellung jedoch ändern, indem Sie auf denDiagrammhintergrund klicken und das Kontrollkästchen "Automatische Aktualisierung" aktivieren.
Wenn Sie auf das Symbol des Felds "Automatische Aktualisierung" klicken, wird dasDialogfeld "Sequenzdiagrammgenerierung" geöffnet, in dem Sie die Einstellung für dieGenerierung von Sequenzdiagrammen ändern können.
Generieren von Sequenzdiagrammen anhand von Eigenschaften9.1.7.3
Sie können in UModel mehrere Sequenzdiagramme anhand mehrerer Optionen sowieSequenzdiagramm anhand von Getter / Setter-Eigenschaften generieren.
Erstellen mehrerer Sequenzdiagramme anhand mehrerer Operationen:
1. Wählen Sie die Menüoption Projekt | Sequenzdiagramme anhand von Codegenerieren.Daraufhin wird das Dialogfeld Wählen Sie eine oder mehrere Operationen ausgeöffnet.
© 2017 Altova GmbH
Verhaltensdiagramme 263UML-Diagramme
Altova UModel 2017
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ö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 Sequenzdiagrammenwahlweise 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 Sequenzdiagrammgeneriert werden soll (Getter/Setter).Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung" geöffnet, in dem Sie dieEigenschaften für die Darstellung des Sequenzdiagramms einstellen können.
264 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
3. Klicken Sie auf OK, um das Sequenzdiagramm zu generieren.
Generieren von Code anhand von Sequenzdiagrammen9.1.7.4
UModel kann Code anhand eines mit mindestens einer Operation verknüpften Sequenzdiagrammsgenerieren.
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 Editionalle drei UModel Editions
Code anhand von Sequenzdiagrammen kann auf zwei Arten erstellt werden:durch einen Reverse Engineering Vorgang. Siehe dazu Generieren vonSequenzdiagrammen anhand von Quellcode,
indem ein mit einer Operation verknüpftes Sequenzdiagramm von Grund auf neu erstelltwird. Mit einem Rechtsklick auf die Operation in der Modell-Struktur können Sie über dasKontextmenü 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 ReverseEngineering aktiviert ist, damit kein Code verloren geht, wenn Sie wieder mit dem ForwardEngineering beginnen.
Dies ist darauf zurückzuführen, dass in einem UML-Sequenzdiagramm nicht alle Funktionen vonVB.NET, Java und C# angezeigt werden können. Daher werden diese Codeabschnitte in Form vonCode-Anmerkungen angezeigt.
So fügen Sie bei der Erstellung eines Sequenzdiagramms einfachen Text als Code
© 2017 Altova GmbH
Verhaltensdiagramme 265UML-Diagramme
Altova UModel 2017
hinzu:1. Hängen Sie eine Anmerkung an eine Lebenslinie in einem Sequenzdiagramm an.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 dieseAnmerkung 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 CodeEngineering verwendet werden soll:
aktivieren Sie im Bereich "Eigenschaften" das Kontrollkästchen "Für das ForwardEngineering verwenden", wenn das Sequenzdiagramm ausgewählt ist.
Der alte Code geht beim Forward Engineering von Code anhand eines Sequenzdiagramms immerverloren, 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 alleSequenzdiagramme 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 denBefehl "Code von Sequenzdiagramm generieren".
266 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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".
© 2017 Altova GmbH
Verhaltensdiagramme 267UML-Diagramme
Altova UModel 2017
Sie werden daraufhin gefragt, ob Sie das neue Diagramm für das Forward Engineeringverwenden möchten.
Das Ergebnis ist ein neues Sequenzdiagramm, das die Lebenslinie dieser Klasse enthält.
Hinzufügen von Code zu einem Sequenzdiagramm9.1.7.4.1
Programmcode kann anhand eines neuen und eines mit Reverse Engineering erstelltenSequenzdiagramms 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 Diagrammenhinzuzufü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 vorhersicherstellen, dass die Codefragmente korrekt und kompilierbar sind.
So fügen Sie Code zu einem Sequenzdiagramm hinzu:
268 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
1. Klicken Sie auf die Schaltfläche "Anmerkung" und klicken Sie anschließend aufdas 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 Codegenerierungverwendet werden kann, so steht die Eigenschaft "Ist Code" im Fenster "Eigenschaften" zurVerfügung. Durch Aktivieren/Deaktivieren des Kontrollkästchens können Sie zwischen "normalen"Anmerkungen und Codegenerierungsanmerkungen wechseln.
NormaleAnmerkungen:Codegenerierungsanmerkungen
- werden mit einem schattierten Eckangezeigt
Wenn das Kontrollkästchen "Für das Forward Engineering verwenden" aktiviert ist, wird der Codeautomatisch bei jedem Forward Engineering aktualisiert. Wenn Änderungen amSequenzdiagramm vorgenommen wurden, wird der Code der Operation immer überschrieben.
Das unten gezeigte Sequenzdiagramm wurde durch Rechtsklick auf die OnCommand-Operationund Auswahl des Befehls "Sequenzdiagramm von Code generieren" generiert. Der C# Codedieses 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.
© 2017 Altova GmbH
Verhaltensdiagramme 269UML-Diagramme
Altova UModel 2017
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 codegeneration.
if (!m_bPlugINVersionOK) { return; }
if (nID == 3 || nID == 6) { OnSetStyles((IApplication)pUModel, "red"); }
if (nID == 4 || nID == 7)
270 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
{ OnSetStyles((IApplication)pUModel, "green"); } GC.Collect();
}
9.1.8 Zeitverlaufsdiagramm
Altova Website: UML-Zeitverlaufsdiagramme
Zeitverlaufsdiagramme dienen zum Darstellen von Änderungen am Status oder Zustand von einemoder mehreren miteinander in Wechselbeziehung stehenden Objekten über einen bestimmtenZeitraum. 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. ImUnterschied zum Sequenzdiagramm sind beim Zeitverlaufsdiagramm die Achsen vertauscht, d.h.der Zeitverlauf wird aufsteigend von links nach rechts dargestellt und Lebenslinien werden inseparaten vertikal angeordneten Bereichen angezeigt.
Zeitverlaufsdiagramme werden im Allgemeinen zum Entwerfen von eingebetteter Software oderEchtzeitsystemen verwendet.
Es gibt zwei verschiedene Arten von Zeitverlaufsdiagrammen: Die eine Art enthält, wie obengezeigt, eine Zustands-Zeitlinie, die andere allgemeinere Art enthält, wie unten gezeigt, eineLebenslinie.
© 2017 Altova GmbH
Verhaltensdiagramme 271UML-Diagramme
Altova UModel 2017
Einfügen von Elementen des Zeitverlaufsdiagramms9.1.8.1
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Zeitverlaufsdiagramm-Symbolleiste auf das entsprechende
Zeitverlaufselement.
2. Klicken Sie zum Einfügen des Elements in das Zeitverlaufsdiagramm. Um mehrereElemente des ausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt undklicken Sie in das Diagrammfenster.
Ziehen vorhandener Elemente in das Zeitverlaufsdiagramm:Sie können Elemente aus anderen Diagrammen, z.B. Klassen, in ein Zeitverlaufsdiagrammeinfügen.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (über dasSuchfunktionstextfeld oder durch Drücken der Tasten Strg + F).
2. Ziehen Sie das Element/die Elemente in das Diagramm.
Lebenslinie9.1.8.2
oder LebenslinieDas Element "Lebenslinie" bildet einen Teil einer Interaktion und steht in zwei Formen zurVerfügung: als Zustands-Zeitlinie oder als Wertverlaufslinie. Um eine Lebenslinie mit mehrerenZeilen zu erstellen, drücken Sie Strg + Eingabetaste, um eine neue Zeile anzulegen.
So fügen Sie eine Zustands-Lebenslinie (Zustandsinvariante) ein und definierenZustandsänderungen:
1. Klicken Sie auf das Symbol "Lebenslinie (Zustand)" in der Titelleiste undanschließend in das Zeitverlaufsdiagramm, um die Lebenslinie einzufügen.
272 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
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 Sieauf die linke Maustaste. Daraufhin wird die Linie ausgewählt.
4. Verschieben Sie den Mauszeiger an die Stelle, an der die Zustandsänderung eintretensoll, 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 aktuellenLebenslinie verschoben werden kann.
Sie können beliebig viele Zustandsänderungen pro Lebenslinie definieren. Wenn auf einerLinie ein rotes Kästchen angezeigt wird, können Sie an eine beliebige Stelle imDiagramm 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:
© 2017 Altova GmbH
Verhaltensdiagramme 273UML-Diagramme
Altova UModel 2017
1. Klicken Sie auf den Zustand und drücken Sie die Entf-Taste oder klicken Sie auf dierechte 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.
Daraufhin wird stattdessen eine Wertverlaufslebenslinie angezeigt, der Kreuzungspunktstellt 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 zwischenden 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 LebenslinienBeim Platzieren oder Stapeln von Lebenslinien werden diese automatisch korrekt angeordnet,wobei auch hinzugefügte Häkchen erhalten bleiben. Durch Ziehen des entsprechendenNachrichtenobjekts können auch Nachrichten zwischen separaten Lebenslinien erstellt werden.
274 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Tick-Symbol9.1.8.3
Tick-SymbolDieses Symbol dient zum Einfügen der Tick-Symbole eines Zeitverlaufslineals auf einerLebenslinie.
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 Sieauf 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 mitder Maus an die gewünschte Stelle.
So ordnen Sie die Tick-Symbole in gleichmäßigen Abständen auf einerLebenslinie an:
1. Ziehen Sie im Hauptfenster ein Rechteck auf, um die einzelnen Tick-Symbole zumarkieren.
2. Klicken Sie in der Symbolleiste auf das Symbol Waagrecht anordnen .
© 2017 Altova GmbH
Verhaltensdiagramme 275UML-Diagramme
Altova UModel 2017
Auslösendes Ereignis9.1.8.4
Auslösendes EreignisDas ExecutionEvent "Auslösendes Ereignis" dient dazu, eine Änderung im Zustand eines Objektsanzuzeigen, die durch das entsprechende auslösende Ereignis verursacht wurde. Dieeingehenden Ereignisse werden mit einer Beschriftung versehen, um das Ereignis zukennzeichnen, 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.
Zeitdauerbedingung9.1.8.5
ZeitdauerbedingungEine Zeitdauer definiert eine Wertespezifikation zur Angabe einer Zeitdauer zwischen einem Start-und einem Endpunkt. Eine Zeitdauer ist oft ein Ausdruck zur Darstellung der Ticks der Uhr, diewä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.
276 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
Die Standard-Minimum- und Maximum-Werte "d..t" werden automatisch vorgegeben.Durch Doppelklick auf die Zeitdauerbedingung oder durch Bearbeitung der Werte imFenster "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.
Zeitbedingung9.1.8.6
Eine Zeitbedingung wird im Allgemeinen als grafische Assoziation zwischen einem Zeitintervallund dem Konstrukt, das es einschränkt, dargestellt. Normalerweise handelt es sich um einegrafischen 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.
© 2017 Altova GmbH
Verhaltensdiagramme 277UML-Diagramme
Altova UModel 2017
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.
Nachricht9.1.8.7
Message (Aufruf) Nachricht (Antwort) Asynchrone Nachricht (Aufruf)
Eine Nachricht ist ein Modellierungselement, das eine bestimmte Art von Kommunikation in einerInteraktion definiert. Dabei kann es sich z.B. um das Auslösen eines Signals, den Aufruf einerOperation, das Erstellen oder Löschen einer Instanz handeln. Die Nachricht definiert die Art derdurch die absendende Ausführungsspezifikation definierten Kommunikation sowie den Absenderund den Empfänger.
Nachrichten werden zwischen sendenden und empfangenden Zeitlinien gesendet und werden alsbeschriftete Pfeile angezeigt.
So fügen Sie eine Nachricht ein: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 Stellegezogen werden kann.
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,
278 UML-Diagramme Verhaltensdiagramme
© 2017 Altova GmbHAltova UModel 2017
können Sie mehrere Nachrichten einfügen, indem Sie mehrmals ins Diagramm klickenund die Maus ziehen.
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".
© 2017 Altova GmbH
Strukturdiagramme 279UML-Diagramme
Altova UModel 2017
9.2 Strukturdiagramme
Diese Diagramme dienen zur Darstellung der Strukturelemente, aus denen ein System oder eineFunktion besteht. Es werden sowohl die statischen, z.B. Klassendiagramm, als auch diedynamischen Beziehungen, z.B. Objektdiagramm, dargestellt.
Strukturdiagramme
Klassendiagramm
Komponentendiagramm
Kompositionsstrukturdiagramm
Deployment-Diagramm
Objektdiagramm
Paketdiagramm
Profildiagramm
9.2.1 Klassendiagramm
Dieser Abschnitt enthält die folgenden Kapitel zu Aufgaben und Begriffen im Zusammenhang mitKlassendiagrammen:
Anpassen von KlassendiagrammenAußerkraftsetzen von Basisklassenoperationen und Implementieren vonSchnittstellenoperationenErstellen von Getter / Setter-MethodenBall-and-socket NotationHinzufügen von Ausnahmeereignissen zu Methoden einer KlasseGenerieren von Klassendiagrammen
Eine grundlegende Einführung in Klassendiagramme finden Sie unter Klassendiagramme imAbschnitt "Tutorial" diese Dokumentation.
Anpassen von Klassendiagrammen9.2.1.1
Erweitern / Ausblenden von Klassenbereichen in einem UML-Diagramm:Es gibt verschiedene Methoden, um die verschiedenen Bereiche von Klassendiagrammen zuerweitern.
Klicken Sie auf das + bzw. das - Symbol der gerade aktiven Klasse, um den jeweiligen
280 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Bereich zu erweitern/auszublenden.Ziehen Sie ein Rechteck (über dem Diagrammhintergrund) auf, um mehrere Klassen zumarkieren und klicken Sie anschließend die Schaltfläche "Erweitern/Ausblenden". Siekö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 einerder Klassen auf die Schaltfläche "Erweitern/Reduzieren", um die entsprechendenBereiche 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 diePakete 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
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önnenauch ändern, welche Art von Sichtbarkeitssymbol angezeigt werden soll.
Klicken Sie im Diagrammfenster auf eine Klasse, anschließend auf das Register Stileund 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 gezeigtenUML-konformen Symbolen.
Ein-/Ausblenden von Knoteninhalt (Klassenattribute, Operationen, Slots)Sie können in UModel nun die Attribute oder Operationen einer Klasse einzeln ein- oderausblenden und definieren, welche angezeigt werden sollen, wenn Sie diese als neue Elemente
© 2017 Altova GmbH
Strukturdiagramme 281UML-Diagramme
Altova UModel 2017
hinzufügen. Beachten Sie bitte: Sie können nun auch Objekt-Slots, also Instanzspezifikationenmit derselben Methode ein- und ausblenden.
Rechtsklicken Sie auf eine Klasse z.B. SavingsAccount und wählen Sie die Menüoption Knoteninhalt ein-/ausblenden.
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 durchdrei 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ästchenim Vorschaufenster deaktivieren.
Ein- / Ausblenden von Klassenattributen oder Operationen - ElementstileSie können in UModel mehrere Instanzen derselben Klasse in einem einzigen Diagramm odersogar in mehreren Diagrammen einfügen. Die Sichtbarkeitseinstellungen können für jede einzelnedieser "Ansichten" der Klasse separat definiert werden. In der Abbildung unten sehen Sie zweiAnsichten derselben Klasse, nämlich SavingsAccount.
282 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Mit Hilfe der Option "Beim Hinzufügen neuer Elemente, die nicht durch Elementstile ausgeblendetwerden" können Sie festlegen, was sichtbar gemacht werden soll, wenn neue Elemente zurKlasse hinzugefügt werden. Elemente können manuell oder automatisch während derCodegenerierung zum Modelldiagramm hinzugefügt werden.
Elemente anzeigen: Zeigt alle neuen Elemente, die zu einer beliebigen Klassenansichthinzugefügt werden.
So wurde z.B. das Attribut interestRate:float in beiden "Ansichten" von SavingsAccountausgeblendet, sodass das Attribut minimumBalance sichtbar bleibt. Das Optionsfeld "Elementeanzeigen" ist für die Klasse auf der linken Seite aktiv.
Wenn Sie in der linken Klasse auf die Auslassungspunkte "..." im Attributbereichdoppelklicken, sehen Sie, dass das Optionsfeld "Elemente anzeigen" aktiv ist.
© 2017 Altova GmbH
Strukturdiagramme 283UML-Diagramme
Altova UModel 2017
Wenn Sie in der rechten Klasse auf die Auslassungspunkte "..." im Attributbereichdoppelklicken, sehen Sie, dass das Optionsfeld "Elemente ausblenden (mit Ausnahme der zudiesem Knoten hinzugefügten)" aktiv ist.
284 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Wenn Sie auf die linke Klasse klicken und F7 drücken (oder in der Modellstruktur auf die Klasseklicken 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 neueElement hier nicht angezeigt wird.
Wenn Sie auf die rechte Klasse klicken und F7 drücken, wird ein neues Attribut (Property2) zurKlasse hinzugefügt. Dieses neue Attribut ist nun sichtbar, da in der Einstellung "Elementeausblenden..." spezifiziert ist "mit Ausnahme der zu diesem Knoten hinzugefügten", wobeials Knoten diese Klasse bzw. dieses Modellierungselement bezeichnet wird.
Das Attribut Property2 ist auch in der linken Klasse sichtbar, da als Einstellung hier "Elementeanzeigen" gewählt wurde.
Bitte beachten Sie:Die Eigenschaftswerte von ausgeblendeten Elementen werden auch ausgeblendet, wenn Sie dieOption "Ausblenden" auswählen.
Ein- /Ausblenden von VS .NET-Bereichen:UModel kann nun .NET-Eigenschaften in ihrem eigenen Bereich anzeigen. Aktivieren Sie dazu aufdem Register "Stile" die Option ".NET-Eigenschaften in eigenem Bereich anzeigen".
© 2017 Altova GmbH
Strukturdiagramme 285UML-Diagramme
Altova UModel 2017
Anzeige von VS .NET-Eigenschaften als AssoziationenUModel kann .NET-Eigenschaften nun als Assoziationen anzeigen.Klicken Sie mit der rechten Maustaste wie unten gezeigt auf eine C#-Eigenschaft, wählen Sie denBefehl "Anzeigen | Alle .NET-Eigenschaften als Assoziationen" und ziehen Sie die Operation indas Diagramm.
Ändern der Syntaxfarbe von Operationen/EigenschaftenDie Syntaxfärbung ist in UModel automatisch aktiviert. Sie können die Syntaxfarben allerdingsnach Ihren eigenen Wünschen anpassen. Unten sehen Sie die Standardeinstellungen.
286 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
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.
© 2017 Altova GmbH
Strukturdiagramme 287UML-Diagramme
Altova UModel 2017
Außerkraftsetzen von Basisklassenoperationen und Implementieren vonSchnittstellenoperationen
9.2.1.2
Sie haben in UModel die Möglichkeit, die Basisklassenoperationen/Schnittstellen vor der CodeEngineering-Phase außer Kraft zu setzen oder Schnittstellenoperationen einer Klasse zuimplementieren. Die kann über die Modell-Struktur, das Register "Favoriten" oder inKlassendiagrammen durchgeführt werden.
1. Rechtsklicken Sie auf eine der abgeleiteten Klassen im Klassendiagramm, z.B. aufCheckingAccount 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 Siemit OK.Mit Hilfe der Schaltflächen "Nicht definierte...auswählen" werden die jeweiligenMethodenarten im Fenster auf der linken Seite ausgewählt.
Bitte beachten Sie:Beim Öffnen des Dialogfelds werden Operationen von Basisklassen und implementiertenSchnittstellen, die dieselbe Signatur wie bestehende Operationen haben, automatischausgewählt, d.h. aktiviert.
288 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Erstellen von Getter / Setter-Methoden9.2.1.3
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-BereichVerwendung des Kontextmenüs zum Öffnen eines Dialogfelds, in dem Sie die get/set-Methoden 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 Artvon get/set-Methode erstellt werden soll.
Wenn Sie den ersten Eintrag auswählen, wird eine get- und set-Methode fürinterestRate:float erstellt.
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.
© 2017 Altova GmbH
Strukturdiagramme 289UML-Diagramme
Altova UModel 2017
Daraufhin erscheint das Dialogfeld "Getters/Setters erstellen", in dem alle in der derzeitaktiven Klasse vorhandenen Attribute angezeigt werden.
2. Verwenden Sie die Schaltflächen, um die Einträge als Gruppe auszuwählen oder klickenSie auf die Kontrollkästchen der einzelnen Methoden.
Bitte beachten Sie:Sie können auch auf ein einzelnes Attribut rechtsklicken und auf dieselbe Art eineOperation dafür erstellen.
Ball-and-socket Notation9.2.1.4
UModel unterstützt die Ball-and-socket Notation von UML-Klassen, die eine Schnittstellebenötigen, ein "Socket" (Buchse) und den Schnittstellennamen anzeigen, während Klassen, dieeine Schnittstelle implementieren den "ball" (Stecker) anzeigen.
In den Abbildungen oben realisiert Class2 Interface1, welche von den Klassen 1, 3 und 4verwendet wird. Die Verwendungssymbole dienten zum Erstellen der Verwendungsbeziehungzwischen den Klassen und der Schnittstelle.
So wechseln Sie zwischen der Standard- und der Ball-and-socket-Ansicht:Klicken Sie auf das Symbol "Darstellung wechseln" am unteren Rand desSchnittstellenelements.
290 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Hinzufügen von Ausnahmeereignissen zu Methoden einer Klasse9.2.1.5
So fügen Sie Ausnahmeereignisse zu Methoden einer Klasse hinzu:
1. Klicken Sie im Fenster "Modellstruktur" auf die Methode der Klasse, zu der Sie dasAusnahmeereignis 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ü denBefehl Ausnahmeereignis hinzufügen.
Daraufhin wird das Feld "Ausnahmeereignis" zum Fenster "Eigenschaften" hinzugefügtund 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 Feldein.
© 2017 Altova GmbH
Strukturdiagramme 291UML-Diagramme
Altova UModel 2017
Generieren von Klassendiagrammen9.2.1.6
Anstatt Klassendiagramme direkt in UModel zu erstellen, können Sie diese beim Import vonQuellcode oder Binärdateien in UModel-Projekte automatisch generieren (siehe Importieren vonQuellcode in Projekte und Importieren von Java-, C#- und VB-Binärdateien). Wenn Sie denAssistenten verwenden, achten Sie auf folgende Dinge:
1) Im Dialogfeld "Quellprojekt importieren", "Binärtypen importieren" bzw. "Quellverzeichnisimportieren" muss das Kontrollkästchen Diagrammgenerierung aktivieren aktiviert sein.
292 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
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.
© 2017 Altova GmbH
Strukturdiagramme 293UML-Diagramme
Altova UModel 2017
Dialogfeld "Generierung von Inhaltsdiagrammen"
Nach Fertigstellung des Imports stehen die generierten Klassendiagramme in der Diagramm-Struktur unter "Klassendiagramme" zur Verfügung.
294 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Diagramm-Struktur
9.2.2 Kompositionsstrukturdiagramm
Altova Website: UML-Kompositionsstrukturdiagramme
In UML 2.0 wurde das Kompositionsstrukturdiagramm hinzugefügt. Es dient dazu, die interneStruktur einschließlich Bereichen, Ports und Konnektoren eines strukturierten Classifier odereiner Kollaboration anzuzeigen.
© 2017 Altova GmbH
Strukturdiagramme 295UML-Diagramme
Altova UModel 2017
Einfügen von Elementen eines Kompositionsstrukturdiagramms9.2.2.1
Ü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-Tastegedrückt und klicken Sie in das Diagrammfenster.
Ziehen bestehender Elemente in das Kompositionsstrukturdiagramm:Die meisten Elemente, die in anderen Kompositionsstrukturdiagrammen vorkommen, können inein bestehendes Kompositionsstrukturdiagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (Sie könnendas Element über das Suchfunktionstextfeld oder mit Hilfe von Strg + F suchen).
2. Ziehen Sie das/die Element(e) in das Kompositionsstrukturdiagramm.
KollaborationFü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.
296 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
KollaborationsanwendungFügt ein Kollaborationsanwendungselement ein. Dabei handelt es sich um eine bestimmteKollaborationsanwendung, wobei bestimmte Klassen oder Instanzen die Rolle der Kollaborationspielen. Eine Kollaborationsanwendung wird als strichlierte Ellipse angezeigt, die den Namen derInstanz, einen Doppelpunkt und den Namen des Kollaborationstyps enthält.
Beim Erstellen von Abhängigkeiten zwischen Kollaborationsanwendungselementen muss dasFeld "Typ" ausgefüllt sein, damit eine Rollenbindung erstellt werden kann und die Zielkollaborationmuss mindestens einen Part/eine Rolle haben.
Part (Eigenschaft)Fügt ein Part-Element ein, das eine Gruppe von einer oder mehreren Instanzen darstellt, die einClassifier besitzt, der diese enthält. Ein Part kann zu Kollaborationen und Klassen hinzugefügtwerden.
PortFügt ein Port-Element ein, das den Interaktionspunkt zwischen einem Classifier und seinerUmgebung definiert. Ein Port-Element kann zu einem Part-Elementen mit einem definierte Typhinzugefügt werden.
KlasseFügt ein Klassenelement ein. Dabei handelt es sich um den eigentlichen Classifier, der in dieserbestimmten Verwendung der Kollaboration vorkommt.
KonnektorFügt ein Konnektorelement hinzu, das verwendet werden kann, um zwei oder mehr Instanzeneines Teils oder Ports zu verbinden. Der Konnektor definiert die Beziehung zwischen denObjekten und identifiziert die Kommunikation zwischen den Rollen.
Abhängigkeit (Rollenbindung)Fügt das Abhängigkeitselement ein. Dieses Element zeigt an, welches verbindbare Element desClassifiers oder der Operation welche Rolle in der Kollaboration spielt.
9.2.3 Komponentendiagramm
Eine Anleitung zum Hinzufügen von Komponentenelementen zum Diagramm finden Sie im Tutorialim Abschnitt Komponentendiagramme.
© 2017 Altova GmbH
Strukturdiagramme 297UML-Diagramme
Altova UModel 2017
9.2.4 Deployment-Diagramm
Eine Anleitung zum Hinzufügen von Knoten und Artefakten zum Diagramm finden Sie im Tutorialim Abschnitt Deployment-Diagramme.
9.2.5 Objektdiagramm
Eine Anleitung zum Hinzufügen neuer Objekte/Instanzen zum Diagramm finden Sie im Tutorial imAbschnitt Objektdiagramme.
298 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
9.2.6 Paketdiagramm
In Paketdiagrammen werden die Struktur von Paketen und ihren Elementen sowie dieentsprechenden Namespaces angezeigt. Zusätzlich dazu können Sie in UModel einen Hyperlinkerstellen und zum jeweiligen Inhalt des Pakets navigieren.
Pakete werden als Ordner dargestellt und können in jedem der UML-Diagramme verwendetwerden. Sie werden jedoch hauptsächlich in Use Case- und Klassendiagrammen verwendet.
© 2017 Altova GmbH
Strukturdiagramme 299UML-Diagramme
Altova UModel 2017
Automatische Generierung von PaketabhängigkeitenUModel bietet die Möglichkeit, ein Paketabhängigkeitsdiagramm für jedes beliebige in der Modell-Struktur bereits existierende Paket zu generieren.
Abhängigkeitslinks zwischen Paketen werden erstellt, wenn Referenzen zwischen denModellierungselementen dieser Pakete vorhanden sind, d.h. wenn es Abhängigkeiten zwischenKlassen, abgeleitete Klassen oder Attributen gibt, die Typen haben, die in einem anderen Paketdefiniert 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.
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 Paketdiagrammelementen9.2.6.1
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Paketdiagramm-Symbolleiste auf das entsprechende Symbol.
300 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
2. Klicken Sie in das Diagramm, um das Element einzufügen. Um mehrere Elemente desausgewählten Typs einzufügen, halten Sie die Strg-Taste gedrückt und klicken Sie indas 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 dasSuchfunktionstextfeld oder durch Drücken der Tasten Strg + F).
2. Ziehen Sie das Element/die Elemente in das Diagramm.
PaketFügt das Paketelement in das Diagramm ein. Pakete dienen zum Gruppieren von Elementen undzur Bereitstellung eines Namespace für die gruppierten Elemente. Da es sich bei einem Paket umeinen Namespace handelt, kann ein Paket einzelne Elemente oder alle Elemente anderer Paketeimportieren. Pakete können auch mit anderen Paketen zusammengeführt werden.
ProfilFügt das Profil-Element ein, einen bestimmten Pakettyp, der auf andere Pakete angewendetwerden kann.
Das Profile-Paket dient zum Erweitern des UML-Metamodells. Das primäre Erweiterungskonstruktist das Stereotyp, welches selbst Teil des Profils ist. Profile müssen immer in Beziehung zueinem Referenz-Metamodell wie z.B. UML stehen und können nicht alleine stehen.
AbhängigkeitFügt das Abhängigkeits-Element ein, welches eine Bereitsteller/Client-Beziehung zwischenModellierungselementen - in diesem Fall Paketen oder Profilen anzeigt.
PaketimportFügt eine <<import>> Beziehung ein, welche anzeigt, dass die Elemente des inkludierten Paketsin das inkludierende Paket importiert werden. Der Namespace des inkludierenden Pakets erhältZugriff auf den inkludierten Namespace; der Namespace des inkludierten Pakets ist nichtbetroffen.
Anmerkung: Elemente, die in einem Paket als "privat" definiert sind, können nichtzusammengeführt oder importiert werden.
PaketmergeFügt eine <<merge>> Beziehung ein, welche anzeigt, dass die Elemente deszusammengeführten (Quell)-Pakets einschließlich aller in das zusammengeführte (Quell)-Paketimportierten Inhalte in das zusammenführende (Ziel)-Paket importiert werden.
Wenn dasselbe Element im Zielpaket bereits vorhanden ist, werden die Definitionen dieserElemente um die Definitionen aus dem Zielpaket erweitert. Aktualisierte oder hinzugefügteElemente werden durch eine Generalisierungsbeziehung zurück zum Quellpaket gekennzeichnet.
© 2017 Altova GmbH
Strukturdiagramme 301UML-Diagramme
Altova UModel 2017
Anmerkung: Elemente, die in einem Paket als "privat" definiert sind, können nichtzusammengeführt oder importiert werden.
ProfilzuweisungFü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 Paketangewendet wird.
Das Profil erweitert das Paket, dem es zugewiesen wurde. Bei Zuweisung eines Profils mit Hilfedes Symbols "Profilzuweisung" stehen alle Stereotype, die Teil dieses Profils sind, auch demPaket zur Verfügung.
Profilnamen werden als strichlierte Pfeile vom Paket zum zugewiesenen Profil mit demSchlüsselwort <<apply>> angezeigt.
Generieren von Paketdiagrammen beim Importieren von Code oderBinärdateien
9.2.6.2
Sie können bei Import von Quellcode oder Binärdateien in ein UModel-Projekt (siehe Importierenvon Quellcode in Projekte und Importieren von Java-, C#- und VB-Binärdateien) Paketdiagrammegenerieren. Nehmen Sie im Importassistenten folgende Einstellungen vor:
1) Im Dialogfeld "Quellprojekt importieren", "Binärtypen importieren" bzw. "Quellverzeichnisimportieren" muss das Kontrollkästchen Diagrammgenerierung aktivieren aktiviert sein.
302 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Dialogfeld "Quellproj ekt importieren"
2) Im Dialogfeld "Generierung von Paketabhängigkeitsdiagrammen"muss die Option Diagramm
generieren aktiviert sein.
© 2017 Altova GmbH
Strukturdiagramme 303UML-Diagramme
Altova UModel 2017
Dialogfeld "Generierung von Paketabhängigkeitsdiagrammen"
Nach Fertigstellung des Imports stehen die generierten Klassendiagramme in der Diagramm-Struktur unter "Klassendiagramme" zur Verfügung.
304 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Diagramm-Struktur
9.2.7 Profildiagramm und Stereotype
Altova Website: UML-Profildiagramme
In UML-Profildiagrammen können Sie benutzerdefinierte Stereotype, Eigenschaftswerte undConstraints in einem bestimmten Diagramm definieren.
Profile und Stereotype dienen zur Erweiterung des UML-Metamodells. Das primäreErweiterungskonstrukt ist das Stereotyp, welches selbst Teil des Profils ist. Profile müssenimmer mit einem Referenzmetamodell wie z.B. UML verknüpft sein. Sie können nicht alleinevorkommen. UModel unterstützt nun das Profildiagramm, in dem Sie Ihre eigenen Stereotypedefinieren können.
Bei Erstellung neuer UModel-Projekte über den Menüeintrag Projekt | Unterprojekt inkludierenmuss 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ürdas Round-Trip Engineering benötigt.
In den folgenden Abschnitten werden folgende Punkte beschrieben:
© 2017 Altova GmbH
Strukturdiagramme 305UML-Diagramme
Altova UModel 2017
Hinzufügen von Stereotypen und Definieren von EigenschaftswertenStereotype und EnumerationenBenutzerdefinierte 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.
Eine Profilzuweisung zeigt an, welche Profile auf ein Paket angewendet wurden. Es handelt sichhierbei 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 desProfils sind, ebenfalls im Paket zur Verfügung stehen.
Profilzuweisungen werden in Form strichlierter Pfeile dargestellt, die vom Paket zumzugewiesenen Profil weisen und mit dem Schlüsselwort <<apply>> versehen sind.
Stereotype:Ein Stereotyp definiert, wie eine bestehende Metaklasse erweitert werden kann. Es handelt sichhierbei um eine Art von Klasse, die Klassen durch Erweiterungen erweitert. Stereotype könnennur in Profilen erstellt werden. Stereotype werden als Klassen, in Klassendiagrammen dargestelltund werden zusätzlich mit dem Schlüsselwort <<stereotype>> oberhalb des Klassennamensversehen.
Stereotype können Eigenschaften haben, die als "Eigenschaftsdefinition" bezeichnet
306 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
werden.Wenn das Stereotyp auf ein Modellelement angewendet wird, werden die Werte derEigenschaften als "Eigenschaftswerte" bezeichnet.Bei Anwendung von Steretypen, die Eigenschaften enthalten, werden dieEigenschaftswerte 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 Sieeinen der vordefinierten Werte auswählen können. Sie können auch den jeweiligen Wertauf dem Register "Eigenschaften" eingeben/auswählen, z.B. <<GetAccessor>>Sichtbarkeit = public, protected usw.
Hinzufügen von Stereotypen und Definieren von Eigenschaftswerten9.2.7.1
In diesem Abschnitt wird die Datei Bank_MultiLanguage.ump aus dem Ordner ...\UModelExamples verwendet.
Erstellen eines Profildiagramms und eines Stereotyps1. 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 |
© 2017 Altova GmbH
Strukturdiagramme 307UML-Diagramme
Altova UModel 2017
Profil und nennen Sie es "MyProfile".
2. Klicken Sie mit der rechten Maustaste in der Modell-Struktur auf das Paket MyProfileund wählen Sie den Befehl Neues Diagramm | Profildiagramm. Daraufhin wird dasProfildiagramm zum ausgewählten Paket hinzugefügt.
3. Ziehen Sie das neu erstellte Profil "MyProfile" aus der Modellstruktur in das neueKlassendiagramm.
4. Ziehen Sie auch das Paket DesignView in das neue Klassendiagramm.
5. Klicken Sie in der Symbolleiste auf die Schaltfläche "Profilzuweisungen" , wählenSie 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 PaketDesignView oder einem seiner Unterpakete verwendet werden.
6. Klicken Sie in der Symbolleiste auf die Schaltfläche "Stereotyp" und fügen Sie einStereotyp "class", z.B. MyKeyValuePair, ein.
7. Drücken Sie F7, um ein Attribut zum Stereotyp hinzuzufügen, z.B. MyKey1. Fügen Sieauf dieselbe Art MyKey2 hinzu.
308 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Damit ist die Definition des Stereotyps für den Moment abgeschlossen. Wir können dasSteretyp nun verwenden/zuweisen, wenn wir ein Attribut zu einer Klasse hinzufügen, dieTeil des Pakets "BankView" ist.
Verwenden / Zuweisen von Stereotypen1. Doppelklicken Sie in der Modellstruktur auf das Klassendiagramm "BankView Main".
Daraufhin wird das Klassendiagramm geöffnet und die Assoziationen zwischen denverschiedenen 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 imListenfeld zur Verfügung steht.
© 2017 Altova GmbH
Strukturdiagramme 309UML-Diagramme
Altova UModel 2017
4. Klicken Sie auf das Kontrollkästchen von MyKeyValuePair um das Stereotyp zuaktivieren/anzuwenden. Die beiden Eigenschaftswerte MyKey1 und MyKey2 werden nununter dem Eintrag "Stereotyp" angezeigt.
5. Doppelklicken Sie in die entsprechenden Felder und geben Sie Werte ein.
Anzeigen von Eigenschaftswerten in einem Diagramm1. 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
310 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
angezeigt. Wenn Sie im Anmerkungselement auf einen Wert doppelklicken, können Sieihn direkt bearbeiten.
Eigenschaftswerte anzeigen: in Bereich
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 mitdem Modellierungselement ein- bzw. ausgeblendet.
Bei Assoziations-(Member) Ends können Stereotype durch Setzen der Option MemberEnd-Stereotype anzeigen auf dem Register "Stile" auf "true" angezeigtwerden.
Nähere Informationen zur Anzeige von Eigenschaftswerten finden Sie unter Anzeige vonEigenschaftswerten.
Stereotype und Enumerationen9.2.7.2
UModel verfügt über eine effiziente Methode zum Auswählen von Enumerationswerten vonStereotypen.
© 2017 Altova GmbH
Strukturdiagramme 311UML-Diagramme
Altova UModel 2017
Klicken Sie auf das Diagrammregister, das die Stereotypdefinition enthält (also auf das zuvorhinzugefügte Profildiagramm).
1. Klicken Sie in der Symbolleiste auf die Schaltfläche "Enumeration" um eineEnumeration 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 / eineneue Eigenschaft z.B. Finished hinzuzufügen.
4. Wählen Sie auf dem Register "Eigenschaften" den Typ "MyEnum" aus.
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 vordefiniertenEigenschaftswerte in einem Popup-Fenster angezeigt. Klicken Sie auf eine derEnumerationen, um sie auszuwählen.
312 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
StandardenumerationswerteUModel gestattet Ihnen, Standardeigenschaftswerte zu definieren. Doppelklicken Sie beimHinzufügen eines Attributs zum Stereotyp in das Feld "Standardwert" und fügen Sie eine derbestehenden Enumerationen als Standardwert hinzu.
In diesem Fall wird der Standardwert "Yes" eingegeben.Wenn eine Eigenschaft zu einer Klasse hinzugefügt und der Typ MyEnum ausgewählt ist, wirdder Standardwert automatisch als Eigenschaftswert eingefügt, d.h. Finished = Yes.
Benutzerdefinierte Stereotypstile9.2.7.3
Sie können nun auch benutzerdefinierte Stile für einzelne Stereotype erstellen. D.h. Sie könnenspezielle Schriftarten, Farben usw. auf jene Klassen anwenden, die einer bestimmtenStereotypart angehören.
So erstellen Sie benutzerdefinierte Stereotypstile:1. Klicken Sie auf ein zuvor definiertes Stereotyp z.B. MyKeyValuePair im
© 2017 Altova GmbH
Strukturdiagramme 313UML-Diagramme
Altova UModel 2017
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 aufdem 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 Stereotyp-
Kontrollkästchen MyKeyValuePair.
Die neue Klasse hat nun die Stile, die dem Stereotyp zugewiesen wurden, z.B. einenHintergrundfarbverlauf in Aquamarin. Beachten Sie, dass die Stereotypstile nichtangewendet werden, wenn das Stereotyp auf eine Eigenschaft oder Operation in derKlasse angewendet wird.
6. Klicken Sie auf die neue Stereotypklasse im Diagramm und anschließend auf dasRegister "Stile".
7. Wählen Sie in der Auswahlliste "Stile" den Eintrag "Angewandte Stereotypstile" aus.
314 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
Sie können nun eine Vorschau der für dieses Stereotyp definierten Stileinstellungen imFenster "Stile" anzeigen. Beachten Sie, dass Sie die Stileinstellungen hier nicht ändernkönnen. Dies muss in dem Klassendiagramm erfolgen, in dem das Stereotyp definiertwurde.
Benutzerdefinierte Stereotypsymbole - Zuweisung9.2.7.4
Sie können in UModel benutzerdefinierte Stereotypsymbole für benutzerdefinierte Stereotypeerstellen.
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.
3. Klicken Sie mit der rechten Maustaste auf MyPackage und wählen Sie den Befehl NeuesDiagramm | Deployment-Diagramm.Daraufhin wird in MyPackage ein Deployment-Diagramm erstellt.
4. Klicken Sie mit der rechten Maustaste in das Diagramm MyPackage und wählen SieNeu | Knoten.
© 2017 Altova GmbH
Strukturdiagramme 315UML-Diagramme
Altova UModel 2017
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".
7. Klicken Sie mit der rechten Maustaste auf das Paket MyProfile und wählen Sie denBefehl Neues Diagramm | Klassendiagramm.
Auswählen des Stereotypsymbols1. Ziehen Sie die Ordner MyPackage und MyProfile aus der Modellstruktur in das
Klassendiagramm.
316 UML-Diagramme Strukturdiagramme
© 2017 Altova GmbHAltova UModel 2017
2. Klicken Sie in der Symbolleiste auf die Schaltfläche "Profilzuweisung" und ziehenSie den Konnektor von MyPackage zu MyProfile.
3. Klicken Sie in der Symbolleiste auf die Schaltfläche "Stereotyp" und klicken Sie indas Paket MyProfile um es einzufügen.
Nehmen Sie auf dem Register "Eigenschaften" die folgenden Änderungen vor, während dasStereotypelement aktiv ist:
4. Ändern Sie den Namen des Elements von Stereotyp1 in "Knoten".
© 2017 Altova GmbH
Strukturdiagramme 317UML-Diagramme
Altova UModel 2017
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ächeum 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 RegisterDeploymentDiagram1 klicken.
8. Klicken Sie im Diagramm auf das Element Node1.9. Aktivieren Sie im Fenster "Eigenschaften" das Kontrollkästchen <Knoten>.
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 dietransparente Hintergrundfarbe.
318 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
9.3 Zusätzliche Diagramme
UModel unterstützt nun den Import und die Generierung von W3C XML Schemas sowie dasForward und Reverse Engineering bei der Codegenerierung.
XML-Schema
9.3.1 XML-Schema-Diagramme
Altova Website: XML-Schemas in UML
In XML-Schema-Diagrammen werden Schemakomponenten in UML-Notation dargestellt. GlobaleElemente, d.h. Elemente, simpleTypes, complexTypes werden als Klassen oder Datentypen mitden Attributen im Attributbereich angezeigt. Es gibt keine Operationen im Operationen-Bereich.Zur Anzeige der Schemainformationen wird das Eigenschaftswert-Notiz Modellierungselementverwendet.
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-Schemaswerden beim Import oder bei der Erstellung in UModel nicht validiert. XML-Schemaswerden bei der Überprüfung der Projektsyntax nicht berücksichtigt. Beim Import eines
© 2017 Altova GmbH
Zusätzliche Diagramme 319UML-Diagramme
Altova UModel 2017
XML-Schemas wird jedoch die Wohlgeformtheit des Schemas überprüft.
320 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
Importieren von XML-Schemas9.3.1.1
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 aktivierenaktiviert ist und klicken Sie zum Fortfahren auf "Weiter".
3. Definieren Sie die Inhaltsdiagrammoptionen in der Gruppe, die diese Überschrift trägt. Mitder ersten Option wird für jedes globale Schema-Element ein separates Diagrammerstellt.
4. Wählen sie die Bereiche aus, die in der Gruppe "Stile" in Klassendiagrammen angezeigt
© 2017 Altova GmbH
Zusätzliche Diagramme 321UML-Diagramme
Altova UModel 2017
werden sollen. Bei Auswahl der Option " Schemainformationen als Eigenschaftswerteanzeigen" werden die Schemainformationen im Eigenschaftswert-Notiz-Modellierungselement 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 inForm von Registern zur Verfügung. In der Abbildung unten sehen Sie den Inhalt des(complexType)-Diagramms EU-Address.
322 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
Bitte beachten Sie:Es wurde ein neues Paket mit dem Namen "Alle Schemas" erstellt und als XSD Namespace Rootdefiniert. Anhand aller XSD Globals wird ein XML-Schema-Diagramm generiert, wobei dieDiagramme unter den jeweiligen Namespace-Paketen angelegt werden.
© 2017 Altova GmbH
Zusätzliche Diagramme 323UML-Diagramme
Altova UModel 2017
So importieren Sie mehrere XML-Schemas:1. Wählen Sie die Menüoption Projekt | XML-Schemaverzeichnis importieren.
2. Aktivieren Sie die Option "Alle Unterverzeichnisse verarbeiten", wenn auch Schemas ausallen Unterverzeichnissen importiert werden sollen.Der restliche Importvorgang erfolgt wie beim Import eines einzelnen XML-Schemas
324 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
(Beschreibung siehe oben).
Bitte beachten Sie:Wenn ein XML-Schema andere Schemas inkludiert oder importiert, werden auch dieseSchemas automatisch importiert.
Anzeige von Eigenschaftswerten - SchemainformationenSchemainformationen, die als Eigenschaftswerte im Anmerkungselement "Eigenschaftswert"angezeigt werden, können auf dem Register "Stile" über den Eintrag "Eigenschaftswerteanzeigen" oder durch Klicken auf das Symbol "Kompaktmodus ein-/ausschalten" rechts unten inder Eigenschaftswert-Anmerkung konfiguriert werden. Hier können Sie zwischen den beiden untengezeigten Modi "Alle" und "Alle, leere ausblenden" wechseln.
Anmerkung: Wenn Sie die Eigenschaftswerte vom Register Stile auswählen, werden die Einstellungen für dieEigenschaftswerte projektweit vorgenommen. Wenn Sie mit der rechten Maustaste auf eineKlasse klicken und Eigenschaftswerte | alle usw. auswählen, so wirkt sich die Einstellung nur aufdie einzeln markierten Klassen aus.
Eigenschaftswerte anzeigen: AlleZeigt die Eigenschaftswerte der Klasse sowie jene der dazugehörigen Attribute, Operationen usw.an.
Eigenschaftswerte anzeigen: Alle, leere ausblenden
© 2017 Altova GmbH
Zusätzliche Diagramme 325UML-Diagramme
Altova UModel 2017
Zeigt nur diejenigen Eigenschaftswerte an, für die ein Wert vorhanden ist, z. B. fixed=true.
Eigenschaftswerte anzeigen: ElementZeigt die Eigenschaftswerte der Klasse an, nicht aber jene der dazugehörigen Attribute,Operationen usw.
Eigenschaftswerte anzeigen: Element, leere ausblendenZeigt nur die Eigenschaftswerte einer Klasse an, jedoch ohne die dazugehörigen Attribute, für dieein Wert vorhanden ist, z.B. id=123
Eigenschaftswerte anzeigen: im Bereich
326 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
Zeigt die Eigenschaftswerte in einem separaten Klassenbereich an.
Eigenschaftswerte anzeigen: in Bereich, leere ausblendenZeigt nur diejenigen Eigenschaftswerte einer Klasse - ohne die dazugehörigen Attribute - an, zudenen ein Wert existiert.
XML-Schema-Annotation:Beachte Sie bitte, dass beim Import eines XML-Schemas nur die erste Annotation eines complex-oder simpleType im Fenster "Dokumentation" angezeigt wird.
Einfügen von XML-Schema-Elementen9.3.1.2
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Symbolleiste auf das jeweilige XML-Schema-Diagramm-Symbol2. 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
© 2017 Altova GmbH
Zusätzliche Diagramme 327UML-Diagramme
Altova UModel 2017
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 XML-Schema-Diagramm eingefügt werden.
1. Suchen Sie das gewünschte Element auf dem Register "Modell-Struktur" (Sie könnendas Element über das Suchfunktionstextfeld oder mit Hilfe von Strg + F suchen).
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-Elementanwenden, das in die Diagramm eingefügt werden kann.
XSD Target NamespaceFügt den Target Namespace für das Schema ein oder definiert ihn. Der XSD Target Namespacemuss einem XSD Namespace Root-Paket angehören.
XSD-SchemaFügt ein XML-Schema ein oder definiert es. Das XSD-Schema muss einem XSD TargetNamespace-Paket angehören.
Element (global) Fügt ein globales Element in das Diagramm ein. Beachten Sie: Auch die Eigenschaft wirdautomatisch im Attribut-Bereich erstellt.
328 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
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 mitobligatorischen Elementen besteht:Hierbei werden ein complexType-Element, ein Sequenz-Element/Kompositor und drei Elementeeingefügt.
1. Klicken Sie auf das Symbol "XSD ComplexType" und anschließend in dasDiagramm, um das Element einzufügen.
2. Doppelklicken Sie auf den Namen und ändern Sie ihn in "Address".
© 2017 Altova GmbH
Zusätzliche Diagramme 329UML-Diagramme
Altova UModel 2017
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 ziehenSie es ins Diagramm.
Daraufhin wird an der Position, an der Sie die Maustaste loslassen, ein SequenzKlassen/Kompositor erstellt.
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.
330 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
7. Gehen Sie für die zwei weiteren Elemente ebenso vor und geben Sie ihnen z.B. dieNamen "Street" und "City".
8. Klicken Sie auf die Eigenschaft "Name" und ziehen Sie sie ins Diagramm.
Erstellen und Generieren eines XML-Schemas9.3.1.3
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. Diessoll 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.
2. Rechtsklicken Sie auf das neue Paket und wählen Sie die Menüoption CodeEngineering | Als XSD Namespace Root definieren.Sie werden gefragt, ob Sie das XSD-Profil zuweisen möchten, wenn es sich hierbei umdie 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.
© 2017 Altova GmbH
Zusätzliche Diagramme 331UML-Diagramme
Altova UModel 2017
7. Rechtsklicken Sie auf das Namespace-Paket und wählen Sie den Befehl NeuesDiagramm | XML-Schema-Diagramm.Sie werden gefragt, ob Sie das Schema-Diagramm zu einem neuen XSD-Schemahinzufü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.
3. Wählen Sie die Menüoption Projekt | Überschreibe Programmcode von UModel-Projekt, und klicken Sie auf OK, um das Schema zu generieren.
332 UML-Diagramme Zusätzliche Diagramme
© 2017 Altova GmbHAltova UModel 2017
Kapitel 10
Austausch von Metadaten zwischen XMI und XML
334 Austausch von Metadaten zwischen XMI und XML
© 2017 Altova GmbHAltova UModel 2017
10 Austausch von Metadaten zwischen XMI undXML
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 UModel-Projekte. Archivieren Sie statt dessen die *.ump-Projektdateien.
Wählen Sie den Menüeintrag Datei | In XMI-Datei exportieren, um eine XMI-Datei aus demUModel-Projekt zu erstellen und Datei | Aus XMI-Datei importieren, um eine zuvor generierteXMI-Datei zu importieren.
Über das Dialogfeld "XMI-Export" können Sie das gewünschte XMI-Format auswählen - XMI fürUML 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 Siesicher, dass Sie das Kontrollkästchen "UModel-Erweiterungen exportieren" aktiviert haben.
Pretty-Print XMI-AusgabeMit dieser Option wird die XMI-Datei mit der richtigen Einrückung der XML-Tags und mitZeilenschaltungen ausgegeben.
UUIDs exportierenIn XMI sind drei Elementidentifikationensversionen definiert: IDs, UUIDs und Labels.
IDs sind innerhalb des XMI-Dokuments eindeutig und werden von den meisten UML-Toolsunterstützt. UModel exportiert standardmäßig diese ID-Typen, d.h. keines derKontrollkästchen muss aktiviert werden.UUID sind Universally Unique Identifiers und bieten eine Methode, um jedem Elementeine GUID (Global Unique Identification) zuzuweisen, d.h. UUIDs sind nicht auf bestimmte
© 2017 Altova GmbH
335Austausch von Metadaten zwischen XMI und XML
Altova UModel 2017
XMI-Dokumente beschränkt. UUIDs werden durch Auswahl des Kontrollkästchens "UUIDsexportieren" generiert. UUIDs werden im Standardformat UUID/GUID gespeichert (z.B. "6B29FC40-CA47-1067-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 exportierenIn XMI ist ein "Erweiterungsmechanismus" definiert, mit Hilfe dessen jede Applikation ihretoolspezifischen Erweiterungen zur UML-Spezifikation exportieren kann. Andere UML-Toolskö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 UML-Spezifikation und müssen daher in XMI gelöscht oder unter "Extensions" gespeichert werden.Wenn sie als Erweiterungen exportiert wurden und wieder importiert werden, werden alleDateinamen und Farben, wie definiert, importiert. Wenn für den Export keine Erweiterungenverwendet werden, gehen diese UModel-spezifischen Daten verloren.
Beim Import eines XMI-Dokuments wird das Format automatisch ermittelt und das Modellgeneriert.
Diagramme exportierenExportiert UModel-Diagramme als "Erweiterungen" in die XMI-Datei. Die Option "UModel-Erweiterungen exportieren" muss aktiv sein, damit das Diagramm als Erweiterung gespeichertwerden kann.
Kapitel 11
UModel-Unterstützung für die Arbeit im Team
338 UModel-Unterstützung für die Arbeit im Team
© 2017 Altova GmbHAltova UModel 2017
11 UModel-Unterstützung für die Arbeit imTeam
UModel-Projekte können in mehrere Unterprojekte aufgeteilt werden, sodass mehrere Entwicklerunterschiedliche Teile eines einzigen Projekts gleichzeitig bearbeiten können. Die einzelnenUnterprojekte können zu einem Versionskontrollsystem hinzugefügt werden.
Das Projekt der obersten Ebene, also das Projekt, von dem aus die Unterprojekte inkludiertwerden können, wird als das Hauptprojekt bezeichnet. Unterprojekte werden auf Paketebene inForm 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 Projekteals Projekte, die vom Hauptprojekt aus schreibgeschützt sind, d.h. nur aufUnterprojektebene bearbeitet werden können.
Unterprojekte können beliebig strukturiert werden, in einer flachen oder einer hierarchischenStruktur oder in Form einer Kombination aus beiden. Dadurch kann praktisch jedes Paket einesHauptprojekts in schreibgeschützte/editierbare Unterprojektdateien aufgeteilt werden.
Beim Code Engineering werden alle untergeordneten Komponenten eines Unterprojektsberücksichtigt. Es besteht kein Unterschied zwischen einer einzelnen Projektdatei oder einerProjektdatei, die aus mehreren editierbaren Unterprojekten besteht.
Dies gilt auch für UML-Diagramme. Auch diese Diagramme können auf der Haupt- oder
© 2017 Altova GmbH
339UModel-Unterstützung für die Arbeit im Team
Altova UModel 2017
Unterprojektebene bearbeitet werden.
340 UModel-Unterstützung für die Arbeit im Team Erstellen und Bearbeiten von Unterprojektdateien
© 2017 Altova GmbHAltova UModel 2017
11.1 Erstellen und Bearbeiten von Unterprojektdateien
Im hier beschriebenen Beispiel wird gezeigt, wie das Projekt Bank_MultiLanguage.ump inmehrere Unterprojekte aufgeteilt wurde.
Bitte beachten Sie:UModel gestattet Ihnen, Pakete und etwaige darin enthaltene UML-Diagramme freizugeben und inmehreren Projekten zu nutzen. Pakete können in andere Projekte entweder durch eine Referenzoder als Kopie inkludiert werden. Nähere Informationen dazu finden Sie unter Freigeben vonPaketen und Diagrammen.
So erstellen Sie eine UnterprojektdateiUnterprojektdateien 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 PaketBanking access und wählen Sie den Befehl Unterprojekt | Neues Unterprojekterstellen.
© 2017 Altova GmbH
Erstellen und Bearbeiten von Unterprojektdateien 341UModel-Unterstützung für die Arbeit im Team
Altova UModel 2017
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 ausbearbeitet werden kann. (Wenn Sie "Schreibgeschützt" auswählen, kann es imHauptprojekt nicht bearbeitet werden.) Klicken Sie anschließend auf OK.
Der Name der Unterprojektdatei wird in eckigen Klammern neben dem Paketnamenangezeigt 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.
342 UModel-Unterstützung für die Arbeit im Team Erstellen und Bearbeiten von Unterprojektdateien
© 2017 Altova GmbHAltova UModel 2017
Bitte beachten Sie:Der Dateipfad des Unterprojekts kann jederzeit durch Rechtsklick auf das Unterprojektund Auswahl des Befehls Unterprojekt | Dateipfad bearbeiten geändert werden.
Öffnen und Bearbeiten von UnterprojektdateienNachdem Sie eine Unterprojektdatei erstellt haben, kann die erzeugte *.ump Datei anschließendgeöffnet und als die UModel-Hauptprojektdatei bearbeitet werden. Dazu sollte es keine nichtaufgelösten Referenzen auf andere Elemente geben. UModel führt bei Erstellung einesUnterprojekts 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 alsHauptprojekt geöffnet. Alle nicht aufgelösten Referenzen werden im Fenster "Meldungen"angezeigt.
© 2017 Altova GmbH
Erstellen und Bearbeiten von Unterprojektdateien 343UModel-Unterstützung für die Arbeit im Team
Altova UModel 2017
Wiederverwendung von UnterprojektenUnterprojekte, die von einem Hauptprojekt abgespalten wurden, können in jedem beliebigenanderen Hauptprojekt verwendet werden.
1. Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie den BefehlProjekt | Unterprojekt inkludieren.
2. Klicken Sie auf die Schaltfläche "Durchsuchen" und wählen Sie die gewünschte .ump-Datei aus, z.B. Banking access.ump.
344 UModel-Unterstützung für die Arbeit im Team Erstellen und Bearbeiten von Unterprojektdateien
© 2017 Altova GmbHAltova UModel 2017
3. Wählen Sie aus, wie die Datei inkludiert werden soll; durch eine Referenz oder als Kopie.
Speichern von ProjektenWenn Sie die Hauptprojektdatei speichern, werden auch alle editierbaren Unterprojektdateiengespeichert, d.h. alle in den freigegebenen Paketen der Unterprojektdateien enthaltenen Datenwerden 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" eineWarnmeldung angezeigt.
Speichern von UnterprojektdateienBeim Speichern von Unterprojekten (von der Hauptprojektebene aus) werden alle Referenzen aufgleichrangige und untergeordnete Unterprojekte berücksichtigt und gespeichert. Wenn z.B. zweigleichrangige Unterprojekte, nämlich sub1 und sub2 existieren und in sub1 Elemente aus sub2verwendet werden, dann wird sub1 so gespeichert, dass darin automatisch auch Referenzen aufsub2 enthalten sind.
Wenn sub1 als ein Hauptprojekt geöffnet wurde, so wird es als unabhängiges Projekt betrachtetund kann ohne Referenz auf das eigentliche Hauptprojekt bearbeitet werden.
Wiedereingliedern von Unterprojekten in das HauptprojektZuvor definierte Unterprojekte können wieder zurück in das Hauptprojekt kopiert werden. Wenndas Unterprojekt keine Diagramme enthält, so wird es sofort wieder eingegliedert. Falls dasUnterprojekt Diagramme enthält, wird das folgende Dialogfeld angezeigt:
1. Klicken Sie mit der rechten Maustaste auf das Unterprojekt und wählen Sie den BefehlUnterprojekt | Als Kopie inkludieren.Daraufhin wird das Dialogfeld "Unterprojekt inkludieren" geöffnet, in dem Sie dieDiagrammstile, die Sie beim Inkludieren des Unterprojekts verwenden möchten, definierenkönnen.
© 2017 Altova GmbH
Erstellen und Bearbeiten von Unterprojektdateien 345UModel-Unterstützung für die Arbeit im Team
Altova UModel 2017
2. Wählen Sie die gewünschte Stiloption aus und klicken Sie anschließend auf OK, um dasProjekt wieder zu inkludieren.
Kapitel 12
Versionskontrolle
348 Versionskontrolle
© 2017 Altova GmbHAltova UModel 2017
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önnenSie Versionskontrollbefehle wie z.B. "Einchecken" oder "Auschecken" direkt über UModel anpraktisch 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 kompatiblenVersionskontrollsystem verbunden werden kann, verwendet werden. Eine Liste von von Altovagetesteten Versionskontrollsystemen und Plug-ins finden Sie unter UnterstützteVersionskontrollsysteme.
Installieren und Konfigurieren des VersionskontrollanbietersUm die auf Ihrem System verfügbaren Versionskontrollsysteme anzuzeigen, gehen Siefolgendermaß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-inswerden in der Dropdown-Liste Aktuelles Versionskontroll-Plug-in angezeigt.
Wenn auf Ihrem System kein kompatibles Plug-in gefunden wurde, wird die folgende Meldungangezeigt:
"Die Registrierung des installierten Versionskontrollproviders konnte nichtgefunden werden oder ist unvollständig."
© 2017 Altova GmbH
349Versionskontrolle
Altova UModel 2017
Bei einigen Versionskontrollsystemen wird das Versionskontroll-Plug-in nicht automatischinstalliert. In diesem Fall müssen Sie es gesondert installieren. Eine genauere Anleitung dazufinden 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 IhremBetriebssystem 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 inUModel zur Verfügung.
Aufrufen der VersionskontrollbefehleDie Versionskontrollbefehle stehen über das Menü Projekt | Versionskontrolle zur Verfügung.
Probleme im Zusammenhang mit den Ressourcen / der GeschwindigkeitBei sehr großen Versionskontrolldatenbanken kann die automatische Durchführung vonStatusaktualisierungen 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 imHintergrund alle xxx Sek." zu deaktivieren oder das Aktualisierungsintervall zu vergrößern.
Anmerkung: Die 64-Bit-Version Ihrer Altova-Applikation unterstützt automatisch alle in dieserDokumentation aufgelisteten 32-Bit-Versionskontrollsysteme. Bei Verwendung einer 64-Bit-Altova-Applikation zusammen mit einem 32-Bit-Versionskontrollsystem ist die Option Statusaktualisierung im Hintergrund alle xxx Sek automatisch deaktiviert und kannnicht ausgewählt werden.
Vergleich mit Altova DiffDogSie können viele Versionskontrollsysteme (einschließlich Git und TortoiseSVN) für dieVerwendung mit Altova DiffDog als Vergleichstool konfigurieren. Nähere Informationen zu DiffDogfinden Sie unter http://www.altova.com/de/diffdog.html. Die Dokumentation zu DiffDog finden Sieunter http://www.altova.com/de/documentation.html.
350 Versionskontrolle Einrichten der Versionskontrolle
© 2017 Altova GmbHAltova UModel 2017
12.1 Einrichten der Versionskontrolle
So richten Sie eine Versionskontrolle ein und stellen Dateien in einem UModel-Projekt unter eineVersionskontrolle:
1. Installieren Sie ein Versionskontrollprogramm (siehe UnterstützteVersionskontrollsysteme), falls noch keines installiert ist. Richten Sie dieVersionskontrolldatenbank (das Repository), in der Sie Ihre Arbeit speichern möchten,ein.
2. Erstellen Sie einen Ordner für den lokalen Arbeitsbereich, der die Arbeitsdateienenthalten soll, die unter Versionskontrolle gestellt werden sollen. Der Ordner, der alle IhreArbeitsbereichordner und -Dateien enthält, wird als ihr lokaler Ordner und der Pfad zumlokalen Ordner als der lokale Pfad bezeichnet. Der Ordner wird an einen bestimmtenOrdner im Repository gebunden.
3. Erstellen Sie in Ihrer Altova-Applikation einen Applikationsprojektordner, zu dem Sie dieunter Versionskontrolle zu stellenden Dateien hinzufügen müssen. Diese Gliederung derDateien in einem Applikationsprojekt ist abstrakt. Die Dateien in einem Projektreferenzieren physische lokal (vorzugsweise in einem einzigen Ordner, falls nötig mitUnterordnern) gespeicherte Dateien.
4. In der Datenbank des Versionskontrollsystems (die auch als Versionskontrolle oderRepository bezeichnet wird) wird ein Ordner erstellt, der an den lokalen Ordner gebundenist. Dieser (als gebundener Ordner bezeichnete) Ordner repliziert die Struktur des lokalenOrdners, sodass sich alle unter Versionskontrolle zu stellenden Dateien an der richtigenStelle im gebundenen Ordner befinden. Der gebundene Ordner wird normalerweiseerstellt, wenn Sie zum ersten Mal eine Datei oder ein Applikationsprojekt zurVersionskontrolle hinzufügen.
© 2017 Altova GmbH
Unterstützte Versionskontrollsysteme 351Versionskontrolle
Altova UModel 2017
12.2 Unterstützte Versionskontrollsysteme
In der nachfolgenden Liste sind die von UModel unterstützten Versionskontrollsystemezusammen mit ihren entsprechenden Versionskontroll-Clients (SCCs) aufgelistet. Die Liste istalphabetisch 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 undVersionskontrollsysteme 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, dieaber 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 SCMProfessional 2.7.127.10 (Server)
Codice Software Plastic SCM Professional2.7.127.10 (SCC Plugin)
Collabnet Subversion 1.5.4 Aigenta Unified SCC 1.0.6PushOK SVN SCC 1.5.1.1PushOK SVN SCC x64 Version 1.6.3.1TamTam SVN SCC 1.2.24
ComponentSoftware CS-RCS (PRO) 5.1 ComponentSoftware CS-RCS (PRO) 5.1
Dynamsoft SourceAnywhere for VSS5.3.2 Standard/Professional Server
Dynamsoft SourceAnywhere für VSS 5.3.2 Client
Dynamsoft SourceAnywhere Hosted Dynamsoft SourceAnywhere Hosted Client (22252)
Dynamsoft SourceAnywhereStandalone 2.2 Server
Dynamsoft SourceAnywhere Standalone 2.2 Client
Git PushOK GIT SCC Plug-in (siehe Versionskontrollemit Git )
IBM Rational ClearCase 7.0.1 (LT) IBM Rational ClearCase 7.0.1 (LT)
March-Hare CVSNT 2.5 (2.5.03.2382) Aigenta Unified SCC 1.0.6
March-Hare CVS Suite 2008 Jalindi Igloo 1.0.3March-Hare CVS Suite Client 2008 (3321)PushOK CVS SCC NT 2.1.2.5PushOK CVS SCC x64 Version 2.2.0.4TamTam CVS SCC 1.2.40
352 Versionskontrolle Unterstützte Versionskontrollsysteme
© 2017 Altova GmbHAltova UModel 2017
Versionskontrollsystem Versionskontroll-Clients
Mercurial 1.0.2 für Windows Sergey Antonov HgSCC 1.0.1
Microsoft SourceSafe 2005 mit CTP Microsoft SourceSafe 2005 mit CTP
Microsoft Visual Studio Team System2008/2010 Team Foundation Server
Microsoft Team Foundation Server 2008/2010MSSCCI 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ürWindows 2009.0.0
Seapine Surround SCM Client 2009.0.0
Serena Dimensions Express/CM 10.1.3für Win32 Server
Serena Dimensions 10.1.3 for Win32 Client
Softimage Alienbrain Server 8.1.0.7300 Softimage Alienbrain Essentials/Advanced Client8.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 Aigenta Unified SCC 1.0.6PushOK SVN SCC 1.5.1.1PushOK SVN SCC x64 Version 1.6.3.1TamTam SVN SCC 1.2.24
© 2017 Altova GmbH
Versionskontrollbefehle 353Versionskontrolle
Altova UModel 2017
12.3 Versionskontrollbefehle
Die Versionskontrollbefehle von UModel werden in den folgenden Abschnitten anhand von VisualSourceSafe 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 UModelwerden die Versionskontrollbefehle und Menübefehle verwendet, die in diesen IDEs zur Verfügungstehen.
Aus Versionskontrolle öffnenVersionskontrolle aktivierenAktuellste Version holenAbrufenOrdner abrufenAuscheckenEincheckenAuschecken rückgängig...Zu Versionskontrolle hinzufügenVon Versionskontrolle ausgliedernAus Versionskontrolle freigebenVerlauf anzeigenUnterschiede anzeigenEigenschaften anzeigenStatus aktualisierenVersionskontrollmanagerVersionskontrolle wechseln
12.3.1 Aus Versionskontrolle öffnen
Mit dem Befehl "Aus Versionskontrolle öffnen" wird ein lokales Projekt anhand einer bestehendenVersionskontrolldatenbank erstellt und unter Versionskontrolle - in diesem Fall SourceSafe -gestellt.
1. Wählen Sie Projekt | Versionskontrolle | Aus Versionskontrolle öffnen. Daraufhinwird das Anmeldedialogfeld geöffnet, in dem Sie Ihre Anmeldedaten eingeben, bevor Siefortfahren 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.
354 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
3. Wählen Sie das gewünschte SourceSafe-Projekt aus, z.B. Bank_CSharp. Wenn der hiervon Ihnen definierte Ordner noch nicht existiert, erscheint ein Dialogfeld, in dem Sieaufgefordert werden, ihn zu erstellen.
4. Klicken Sie auf Ja, um das neue Verzeichnis zu erstellen. Das Dialogfeld "Öffnen" wirdangezeigt.
© 2017 Altova GmbH
Versionskontrollbefehle 355Versionskontrolle
Altova UModel 2017
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 unterVersionskontrolle gestellt. Angezeigt wird dies in der Modell-Struktur durch einSchlosssymbol über dem Root-Ordner. Der Root-Ordner repräsentiert sowohl dieProjektdatei als auch das Arbeitsverzeichnis für Versionskontrolloperationen.
Das Verzeichnis "BankCSharp" wurde lokal erstellt. Sie können nun mit diesen Dateiennormal arbeiten.
Anmerkung: Informationen, wie Sie die beim Synchronisieren von Code generierten Codedateienunter Versionskontrolle stellen, finden Sie unter: Hinzufügen zur Versionskontrolle
Symbole der Versionskontrolle:
oder Das Vorhängeschloss-Symbol zeigt an, dass diese Datei oder dieser Ordner unterVersionskontrolle steht, aber derzeit nicht ausgecheckt ist.
oder Das rote Kontrollhäkchen zeigt an, dass diese Datei ausgecheckt ist, d.h. dass die UModel-Projektdatei (oder Codedatei) zur Bearbeitung ausgecheckt wurde.Das Sternchen in der Titelleiste der Applikation bedeutet, dass diese Datei verändert wurde. BeimSchließen werden Sie aufgefordert, die Datei zu speichern.
oder
Das Personensymbol zeigt an, dass die Datei(en) von jemand anderem im Netzwerk oder vonIhnen in ein anderes Arbeitsverzeichnis ausgecheckt wurde(n).
12.3.2 Versionskontrolle aktivieren
Mit Hilfe dieses Befehls können Sie die Versionskontrolle für ein UModel-Projekt aktivieren oderdeaktivieren. Der Befehl steht über das Projekt-Menü Projekt | Versionskontrolle |
356 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
Versionskontrolle aktivieren zur Verfügung. Bei Auswahl dieser Option für eine Datei odereinen 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 derverschiedenen 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 entfernenmö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.
12.3.3 Aktuellste Version holen
Mit diesem Befehl wird die aktuellste Version der ausgewählten Datei(en) aus demVersionskontrollspeicher in das Arbeitsverzeichnis geholt. Die Dateien werden alsschreibgeschützte Dateien und nicht ausgecheckt abgerufen.
Wenn die betroffenen Dateien derzeit ausgecheckt sind, geschehen je nach Version desVersionskontroll-Plugin verschiedene Dinge: Es geschieht nichts, neue Daten werden in Ihrerlokalen 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 Abrufoptionendefinieren.
Beachten Sie, dass dieser Befehl bei Ausführung an einem Ordner automatisch eine rekursiveOperation "Aktuellste Version holen" ausführt, d.h. alle anderen Dateien, die sich in derPakethierarchie 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 holenmöchten.
2. Wählen Sie Projekt | Versionskontrolle | Aktuellste Version holen.
© 2017 Altova GmbH
Versionskontrollbefehle 357Versionskontrolle
Altova UModel 2017
12.3.4 Abrufen
Ruft eine schreibgeschützte Kopie der ausgewählten Dateien ab und platziert Sie in denArbeitsordner. 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ählenWählt alle Dateien im Listenfeld aus.
ErweitertMit Hilfe dieser Option können Sie die Optionen Replace writable und Set timestamp in denentsprechenden Auswahllisten auswählen.
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
358 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
12.3.5 Ordner abrufen
Ruft schreibgeschützte Kopien von Dateien in den ausgewählten Ordnern ab und platziert Sie inden 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 derVersionskontrolldatenbank.
Rekursiv (Struktur abrufen)Ruft alle Dateien aus der Ordnerstruktur ab, die sich unterhalb des ausgewählten Ordnersbefinden.
ErweitertMit Hilfe dieser Option können Sie die Optionen Replace writable und Set timestamp in denentsprechenden Auswahllisten auswählen.
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
© 2017 Altova GmbH
Versionskontrollbefehle 359Versionskontrolle
Altova UModel 2017
12.3.6 Auschecken
Mit diesem Befehl checken Sie die aktuellste Version der ausgewählten Datei(en) aus undplatzieren beschreibbare Kopien davon in das Arbeitsverzeichnis. Die Dateien werden für andereBenutzer als "ausgecheckt" markiert.
So checken Sie Dateien aus:Wählen Sie die gewünschte Datei bzw. den gewünschten Ordner in der Modell-Strukturaus.Wählen Sie Projekt | Versionskontrolle | Auschecken.
Anmerkung:Sie können die Anzahl der auszucheckenden Dateien ändern, indem Sie die einzelnenKontrollkä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 Dateienmittels Strg + Klick)Projektordner - klicken Sie in der Modellstruktur auf den Ordner (oder mehrere Ordnermittels Strg + Klick)
oder Das rote Kontrollhäkchen zeigt an, dass die Datei/der Ordner ausgecheckt ist.#
ErweitertMit Hilfe dieser Option können Sie die Optionen Replace writable und Set timestamp in denentsprechenden Auswahllisten auswählen.
360 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
12.3.7 Einchecken
Mit diesem Befehl checken Sie zuvor ausgecheckte Dateien, d.h. Ihre lokal aktualisiertenDateien, 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 einzelnenKontrollkästchen in der Liste der Dateien aktivieren.
Folgende Objekte können eingecheckt werden:Einzelne Dateien - klicken Sie in der Modell-Struktur auf die Datei (oder mehrere Dateienmittels Strg + Klick)Ordner - klicken Sie in der Modellstruktur auf die Ordner (mittels Strg + Klick)
© 2017 Altova GmbH
Versionskontrollbefehle 361Versionskontrolle
Altova UModel 2017
oder
Das Vorhängeschloss-Symbol zeigt an, dass sich die Datei/der Ordner unter Versionskontrollebefindet, aber derzeit nicht ausgecheckt ist.
12.3.8 Auschecken rückgängig...
Mit diesem Befehl werden Änderungen in zuvor ausgecheckten Dateien, also lokal aktualisiertenDateien 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 ausWählen Sie Projekt | Versionskontrolle | Auschecken rückgängig.
Anmerkung:Sie können die Anzahl der Dateien ändern, indem Sie die einzelnen Kontrollkästchen inder Liste der Dateien aktivieren.
Die Option "Auschecken rückgängig" kann auf die folgenden Dateien angewendet werden:Einzelne Dateien - klicken Sie in der Modell-Struktur auf die Datei (oder mehrere Dateienmittels Strg + Klick)Ordner - klicken Sie in der Modellstruktur auf die Ordner (mittels Strg + Klick)
ErweitertMit Hilfe dieser Option können Sie die Optionen Replace writable und Set timestamp in denentsprechenden Auswahllisten auswählen.
362 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
12.3.9 Zu Versionskontrolle hinzufügen
Fügt die ausgewählten Dateien oder Ordner zur Versionskontrolldatenbank hinzu und stellt sieunter Versionskontrolle. Wenn Sie ein neues UModel-Projekt hinzufügen, werden Sie aufgefordertden Arbeitsbereichsordner und den Pfad anzugeben, unter dem das Projekt gespeichert werdensoll.
Nachdem Sie die UModel-Projektdatei (*.ump) unter Versionskontrolle gestellt haben, können Sieanschließend die beim Code Engineering erzeugten Codedateien ebenfalls zur Versionskontrollehinzufügen. Bitte beachten Sie, dass die generierten Codedateien und das UModel-Projekt in dasoder unterhalb desselben SourceSafe-Arbeitsverzeichnisses gelegt werden müssen. Das indiesem 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 zurKomponente "BankView".
2. Klicken Sie auf die BankView-Komponente und klicken Sie im Fenster "Eigenschaften"auf das Durchsuchen-Symbol neben dem Feld "Verzeichnis".
© 2017 Altova GmbH
Versionskontrollbefehle 363Versionskontrolle
Altova UModel 2017
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
OK.
Im Meldungsfenster wird der Code aus dem Projektvorgang angezeigt.Es erscheint ein Meldungsfeld, in dem Sie gefragt werden, ob Sie die neu erstelltenDateien unter Versionskontrolle stellen möchten.
6. Klicken Sie auf Ja.
364 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
7. Daraufhin wird das Dialogfeld "Zu Versionskontrolle hinzufügen" geöffnet, in dem Sie dieDateien auswählen können, die unter Versionskontrolle gestellt werden sollen.
8. Klicken Sie auf OK, sobald Sie die gewünschten Dateien ausgewählt haben.Neben den einzelnen unter Versionskontrolle gestellten Klassen/Dateiquellen erscheintnun ein Vorhängeschloss-Symbol.
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 nichtausgecheckt werden. Mit Hilfe des Befehls "Zu Versionskontrolle hinzufügen" können Sie dieDateien wieder unter Versionskontrolle stellen.
So entfernen Sie Dateien aus der Versionskontrolle:Wählen Sie die gewünschten Dateien in der Modellstruktur aus
© 2017 Altova GmbH
Versionskontrollbefehle 365Versionskontrolle
Altova UModel 2017
Wählen Sie Projekt | Versionskontrolle | Von Versionskontrolle ausgliedern.
Anmerkung:Sie können die Anzahl der auszugliedernden Dateien ändern, indem Sie die einzelnenKontrollkästchen in der Liste der Dateien aktivieren.
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
12.3.11 Aus Versionskontrolle freigeben
Mit diesem Befehl werden Dateien aus anderen Projekten/Ordnern im ausgewählten Ordner in dieVersionskontrollspeicherschnittstelle 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 freigebenmö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. dieKomponente BankView im Ordner Component View.
2. Wählen Sie im Listenfeld "Projekte" den Projektordner aus, der die Datei enthält.
366 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
3. Wählen Sie im Listenfeld "Files to share" die gewünschte Datei aus und klicken Sie aufdie Schaltfläche "Freigeben".Die Datei wird nun aus der Liste "Files to share" entfernt.
4. Klicken Sie zum Fortfahren auf "Schließen".
Branch after shareGibt die Datei frei und erstellt einen neuen Branch zum Erstellen einer separaten Version.
12.3.12 Verlauf anzeigen
Mit diesem Befehl zeigen Sie den Verlauf einer unter Versionskontrolle stehenden Datei an. Siekö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.
© 2017 Altova GmbH
Versionskontrollbefehle 367Versionskontrolle
Altova UModel 2017
3. Wählen Sie den gewünschten Eintrag und bestätigen Sie mit OK.
Dieses Dialogfeld bietet verschiedene Möglichkeiten, um bestimmte Versionen derausgewählten Datei zu vergleichen und abzurufen. Wenn Sie auf einen Eintrag in derListe doppelklicken, wird das Dialogfeld "Verlauf" für diese Datei geöffnet.
SchließenSchließt dieses Dialogfeld.
AnsichtÖffnet ein weiteres Dialogfeld, in dem Sie die Art des Ansichtsprogramms auswählenkönnen, in dem Sie die Datei anzeigen möchten.
DetailsÖffnet ein Dialogfeld, in dem Sie die Eigenschaften der gerade aktiven Datei sehen.
368 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
AbrufenDamit können Sie eine der vorherigen Versionen der Datei aus der Versionsliste in dasArbeitsverzeichnis holen.
AuscheckenDamit können Sie die neueste Version der Datei auschecken.
DiffÖffnet das Dialogfeld Vergleichsoptionen, in dem Sie die Vergleichsoptionen zur Anzeigeder 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 Dateienanzuzeigen.
PinMarkiert eine Version der Datei bzw. hebt die Markierung auf. Damit können Sie dieDateiversion definieren, die für den Dateivergleich verwendet werden soll.
RollbackFührt ein Rollback für die ausgewählte Version der Datei durch.
Report Generiert einen Verlaufsbericht, den Sie an den Drucken, die Datei oder dieZwischenablage senden können.
HilfeÖffnet die Online-Hilfe des Versionskontrollanbieters für das Plugin.
12.3.13 Unterschiede anzeigen
Dieser Befehl ermöglicht die Anzeige von Unterschieden zwischen der in der Versionskontroll-Ablage 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 dieseDatei im Textfeld "Vergleichen" verwenden. Sie können mit Hilfe der Durchsuchen-Schaltfläche 2beliebige 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.
© 2017 Altova GmbH
Versionskontrollbefehle 369Versionskontrolle
Altova UModel 2017
3. Wählen Sie die gewünschten Einträge und bestätigen Sie mit OK.
Die Unterschiede zwischen beiden Dateien werden in beiden Fenstern farblich markiert (indiesem Beispiel wird MS Source-Safe verwendet).
12.3.14 Eigenschaften anzeigen
Mit diesem Befehl können Sie die Eigenschaften der ausgewählten Datei anzeigen. Die Anzeigekann je nach verwendetem Versionskontrollprodukt unterschiedlich sein.
So zeigen Sie die Eigenschaften der aktuell ausgewählten Datei an:Wählen Sie Projekt | Versionskontrolle | Eigenschaften.
370 Versionskontrolle Versionskontrollbefehle
© 2017 Altova GmbHAltova UModel 2017
Dieser Befehl kann jeweils nur an einer einzelnen Datei ausgeführt werden.
12.3.15 Status aktualisieren
Mit diesem Befehl aktualisieren Sie den Status aller Projektdateien unabhängig von ihremderzeitigen Status.
12.3.16 Versionskontrollmanager
Mit diesem Befehl starten Sie die ursprüngliche Oberfläche Ihrer Versionskontroll-Software.
12.3.17 Versionskontrolle wechseln
Über dieses Dialogfeld können Sie das Versionskontrollsystem-Binding wechseln. Klicken Siedazu zuerst auf die Schaltfläche "Bindung aufheben" und anschließend (optional) auf dieSchaltfläche "Auswählen", um ein neues Versionskontrollsystem auszuwählen. Klicken Sieanschließend auf die Schaltfläche "Binden", um eine Bindung zu einem neuen Pfad in derSpeicherschnittstelle zu erstellen.
© 2017 Altova GmbH
Versionskontrollbefehle 371Versionskontrolle
Altova UModel 2017
372 Versionskontrolle Versionskontrolle mit Git
© 2017 Altova GmbHAltova UModel 2017
12.4 Versionskontrolle mit Git
Unterstützung für Git als Versionskontrollsystem in UModel steht in Form eines Drittanbieter-Plug-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 zumExperimentieren zur Verfügung. Um das Plug-in verwenden zu können, müssen Sie beimPlug-in-Anbieter registriert sein.
Mit Hilfe des GIT SCC Plug-in können Sie über die Befehle im Menü Projekt | Versionskontrollevon 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ürdie eine andere Art von Design als von Git verwendet wird, bereitgestellt werden. Daher bildet dasPlug-in eine Zwischenschaltung zwischen "Visual Source Safe"-Funktionalitäten und Git-Funktionalitäten. Das bedeutet einerseits, dass ein Befehl wie z.B. Aktuellste Version holen fürGit eventuell so nicht verwendet werden kann. Andererseits gibt es einige neue Git-spezifischeAktionen, die über das Plug-in im Dialogfeld "Versionskontrollmanager" zur Verfügung gestelltwerden (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 grundlegendeArbeitsablauf beschrieben:
Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-inHinzufügen eines Projekts zur Git-VersionskontrolleKlonen eines Projekts anhand der Git-Versionskontrolle
© 2017 Altova GmbH
Versionskontrolle mit Git 373Versionskontrolle
Altova UModel 2017
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-PushOKGIT SCC Plug-in installiert, registriert und als Versionskontrollanbieter ausgewählt werden. Diesgeschieht 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 dieInstallationsanweisungen.
2. Klicken Sie im Menü Projekt von UModel auf Versionskontrolle wechseln undvergewissern Sie sich, dass PushOk GITSCC als Versionskontroll-Provider ausgewähltist. Wenn Push Ok GITSCC in der Liste der Provider nicht angezeigt wird, war dieInstallation des Plug-in wahrscheinlich nicht erfolgreich. Lesen Sie in diesem Fall in derDokumentation 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 zuregistrieren, klicken Sie auf Registrierung und befolgen Sie die Anweisungen desAssistenten, um die Registrierung abzuschließen.
12.4.2 Hinzufügen eines Projekts zur Git-Versionskontrolle
Sie können UModel -Projekte als Git Repositories speichern. Die Struktur der zum Projekthinzugefügten Dateien oder Ordner würde anschließend der Struktur des Git Repositoryentsprechen.
So fügen Sie ein Projekt zu einer Git-Versionskontrolle hinzu:
1. Stellen Sie sicher, dass das PushOK GIT SCC Plug-in als Versionskontrollanbieterausgewä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 keineValidierungsfehler 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.
374 Versionskontrolle Versionskontrolle mit Git
© 2017 Altova GmbHAltova UModel 2017
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 Projekthinzufügen. Beachten Sie, dass alle Projektdateien und -ordner sich unter dem Root-Ordner desProjekts befinden müssen. Wenn das Projekt z.B. im Ordner C:\MyRepo angelegt wurde, sosollten 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, wirdeine Warnmeldung angezeigt:
© 2017 Altova GmbH
Versionskontrolle mit Git 375Versionskontrolle
Altova UModel 2017
12.4.3 Klonen eines Projekts anhand der Git-Versionskontrolle
Projekte, die bereits zur Git-Versionskontrolle hinzugefügt wurden (siehe Hinzufügen einesProjekts zur Git-Versionskontrolle) können folgendermaßen über das Git Repository geöffnetwerden:
1. Vergewissern Sie sich, dass das PushOK GIT SCC Plug-in als Versionskontroll-Provider ausgewählt ist (siehe Aktivieren der Git-Versionskontrolle mit dem Git SCC Plug-in ).
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 Projekterstellt werden soll und klicken Sie auf Weiter. Wenn der lokale Ordner vorhanden ist,wird (auch wenn er leer ist) das folgende Dialogfeld aufgerufen:
376 Versionskontrolle Versionskontrolle mit Git
© 2017 Altova GmbHAltova UModel 2017
5. Klicken Sie zur Bestätigung auf Ja und anschließend auf Weiter.
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 dieProjektdatei aus, um den Projektinhalt in UModel zu laden.
Kapitel 13
UModel Diagrammsymbole
378 UModel Diagrammsymbole
© 2017 Altova GmbHAltova UModel 2017
13 UModel Diagrammsymbole
Der folgende Abschnitt enthält eine Kurzübersicht über die Symbole, die in den einzelnenModelldiagrammen zur Verfügung stehen.
Die Symbole sind in zwei Gruppen unterteilt:Hinzufügen - Zeigt eine Liste von Elementen an, die zum Diagramm hinzugefügt werdenkönnen. Beziehung - Zeigt eine Liste von Beziehungsarten an, die zwischen Elementen imDiagramm erstellt werden können.
© 2017 Altova GmbH
Aktivitätsdiagramm 379UModel Diagrammsymbole
Altova UModel 2017
13.1 Aktivitätsdiagramm
HinzufügenAktion (Aufrufverhalten-Aktion)Aktion (Aufrufoperationsaktion)EreignisannahmeaktionEreignisannahmeaktion (Zeitereignis)Signalsendeaktion
Verzweigungsknoten (Verzweigung)VerbindungsknotenStartknotenAktivitätsendknotenEndknoten für KontrollflüsseParallelisierungsknoten (vertikal)Parallelisierungsknoten (horizontal)SynchronisationsknotenSynchronisationsknoten (horizontal)
InputpinOutputpinWert-Pin
ObjektknotenPufferknotenDatenspeicherknotenAktivitätsbereich (horizontal)Aktivitätsbereich (vertikal)Aktivitätsbereich 2-dimensional
KontrollflussObjektflussAusnahme-Handler
AktivitätAktivitätsparameterknotenStrukturierterAktivitätsknotenMengenverarbeitungsbereichErweiterungsknotenUnterbrechungsbereich
AnmerkungAnmerkung verknüpfen
380 UModel Diagrammsymbole Klassendiagramm
© 2017 Altova GmbHAltova UModel 2017
13.2 Klassendiagramm
Beziehung:AssoziationAggregationKompositionAssoziationsklasseAbhängigkeitVerwendungSchnittstellenrealisierungGeneralisierung
Hinzufügen:PaketKlasseSchnittstelleEnumerationDatentypPrimitivtypProfil StereotypProfilzuweisungInstanzspezifikation
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Kommunikationsdiagramm 381UModel Diagrammsymbole
Altova UModel 2017
13.3 Kommunikationsdiagramm
HinzufügenLebenslinieNachricht (Aufruf)Nachricht (Antwort)Nachricht (Erstellung)Nachricht (Löschung)
AnmerkungAnmerkung verknüpfen
382 UModel Diagrammsymbole Kompositionsstrukturdiagramm
© 2017 Altova GmbHAltova UModel 2017
13.4 Kompositionsstrukturdiagramm
HinzufügenKollaborationKollaborationsanwendungPart (Eigenschaft)KlasseSchnittstellePort
BeziehungKonnektorAbhängigkeit (Rollenbindung)SchnittstellenrealisierungVerwendung
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Komponentendiagramm 383UModel Diagrammsymbole
Altova UModel 2017
13.5 Komponentendiagramm
Hinzufügen:PaketSchnittstelleKlasseKomponenteArtefakt
Beziehung:RealisierungSchnittstellenrealisierungVerwendungAbhängigkeit
AnmerkungAnmerkung verknüpfen
384 UModel Diagrammsymbole Deployment-Diagramm
© 2017 Altova GmbHAltova UModel 2017
13.6 Deployment-Diagramm
Hinzufügen:PaketKomponenteArtefaktKnotenGerätAusführungsumgebung
Beziehung:ManifestationDeploymentAssoziationGeneralisierungAbhängigkeit
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Interaktionsübersichtsdiagramm 385UModel Diagrammsymbole
Altova UModel 2017
13.7 Interaktionsübersichtsdiagramm
HinzufügenAufrufverhalten - Aktion (Interaktion)Aufrufverhalten - Aktion (Interaktionsverwendung)VerzweigungsknotenVerbindungsknotenStartknotenAktivitätsendknotenParallelisierungsknotenParallelisierungsknoten (Horizontal)SynchronisationsknotenSynchronisationsknoten (Horizontal)Zeitdauerbedingung
BeziehungKontrollfluss
AnmerkungAnmerkung verknüpfen
386 UModel Diagrammsymbole Objektdiagramm
© 2017 Altova GmbHAltova UModel 2017
13.8 Objektdiagramm
Beziehung:AssoziationAssoziationsklasseAbhängigkeitVerwendungSchnittstellenrealisierungGeneralisierung
Hinzufügen:PaketKlasseSchnittstelleEnumerationDatentypPrimitivtypInstanzspezifikation
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Paketdiagramm 387UModel Diagrammsymbole
Altova UModel 2017
13.9 Paketdiagramm
HinzufügenPaketProfil
BeziehungAbhängigkeitPaketimportPaketmergeProfilzuweisung
AnmerkungAnmerkung verknüpfen
388 UModel Diagrammsymbole Profildiagramm
© 2017 Altova GmbHAltova UModel 2017
13.10 Profildiagramm
HinzufügenProfilStereotyp
BeziehungGeneralisierungProfilzuweisungPaketimportElementimport
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Protokoll-Zustandsdiagramm 389UModel Diagrammsymbole
Altova UModel 2017
13.11Protokoll-Zustandsdiagramm
HinzufügenEinfacher ZustandZusammengesetzter ZustandOrthogonaler ZustandUnterautomatenzustand
EndzustandAnfangszustand
EintrittspunktAustrittspunktEntscheidungKreuzungBeendungGabelungGabelung (horizontal)VereinigungVereinigung (horizontal)Verbindungspunktreferenz
BeziehungProtocol Transition
AnmerkungAnmerkung verknüpfen
390 UModel Diagrammsymbole Sequenzdiagramm
© 2017 Altova GmbHAltova UModel 2017
13.12 Sequenzdiagramm
HinzufügenLebenslinieCombined FragmentCombined Fragment (Alternativen)Combined Fragment (Loop)InteraktionsverwendungGateZustandsinvarianteZeitdauerbedingungZeitbedingung
Nachricht (Aufruf)Nachricht (Antwort) Nachricht (Erstellung)Nachricht (Löschung)
Asynchrone Nachricht (Aufruf)Asynchrone Nachricht (Antwort)Asynchrone Nachricht (Löschung)
AnmerkungAnmerkung verknüpfen
Keine NachrichtennummerierungEinfache NachrichtennummerierungHierarchische Nachrichtennummerierung
Verschieben zusammengehöriger Nachrichten ein/ausAutomatische Erstellung von Antworten auf Nachrichten (Call) ein/ausAutomatische Erstellung von Operationen in der Zielkomponente durch Eingabe vonOperationsnamen ein-/ausschalten
© 2017 Altova GmbH
Zustandsdiagramm 391UModel Diagrammsymbole
Altova UModel 2017
13.13 Zustandsdiagramm
HinzufügenEinfacher ZustandZusammengesetzter ZustandOrthogonaler ZustandUnterautomatenzustand
AnfangszustandEndzustandEintrittspunktAustrittspunktEntscheidungKreuzungBeendungGabelungGabelung (horizontal)VereinigungVereinigung (horizontal)Deep historyShallow historyVerbindungspunktreferenz
BeziehungTransition
AnmerkungAnmerkung verknüpfen
Automatische Erstellung von Operationen in der Zielkomponente durch Eingabe vonOperationsnamen ein-/ausschalten
392 UModel Diagrammsymbole Zeitverlaufsdiagramm
© 2017 Altova GmbHAltova UModel 2017
13.14 Zeitverlaufsdiagramm
HinzufügenLebenslinie (Zustand/Bedingung)Lebenslinie (Allgemeiner Wert)Tick-SymbolAuslösendes EreignisZeitdauerbedingungZeitbedingung
Nachricht (Aufruf)Nachricht (Antwort)Asynchrone Nachricht (Aufruf)
AnmerkungAnmerkung verknüpfen
© 2017 Altova GmbH
Use Case-Diagramm 393UModel Diagrammsymbole
Altova UModel 2017
13.15 Use Case-Diagramm
Hinzufügen:PaketAkteurUse Case
Beziehung:AssoziationGeneralisierungInclude Extend
AnmerkungAnmerkung verknüpfen
394 UModel Diagrammsymbole XML-Schema-Diagramm
© 2017 Altova GmbHAltova UModel 2017
13.16 XML-Schema-Diagramm
HinzufügenXSD Target NamespaceXSD SchemaXSD Element (global) XSD GroupXSD ComplexTypeXSD ComplexType (simpleContent)XSD SimpleTypeXSD ListXSD UnionXSD EnumerationXSD AttributeXSD AttributeGroupXSD NotationXSD Import
BeziehungXSD IncludeXSD RedefineXSD RestrictionXSD ExtensionXSD Substitution
AnmerkungAnmerkung verknüpfen
Kapitel 14
Menüreferenz
396 Menüreferenz
© 2017 Altova GmbHAltova UModel 2017
14 Menüreferenz
Im folgenden Abschnitt sind alle Menüs und Menüoptionen in UModel mit einer kurzenBeschreibung dazu aufgelistet.
© 2017 Altova GmbH
Datei 397Menüreferenz
Altova UModel 2017
14.1 Datei
NeuLöscht das Diagrammregister, falls ein früheres Projekt vorhanden ist, und erstellt ein neuesUModel-Projekt.
ÖffnenÖffnet ein zuvor definiertes Modellierungsprojekt. Wählen Sie im Dialogfeld "Öffnen" eine zuvorgespeicherte Projektdatei (*.ump) aus.Nachstehend sehen Sie das Standarddialogfeld zum Öffnen von Dateien. Beachten Sie bitte dieSchaltfläche "Zu URL wechseln" am unteren Rand des Dialogfelds.
Wenn Sie auf die Schaltfläche "Zu URL wechseln" klicken, ändert sich das Aussehen desDialogfelds 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ästchenMicrosoft® SharePoint® Server. Nähere Informationen zum Arbeiten mit Dateien diesesServertyps finden Sie unter den Anmerkungen weiter unten zu Microsoft® SharePoint®
398 Menüreferenz Datei
© 2017 Altova GmbHAltova UModel 2017
Server.
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 imHauptfenster angezeigt.
Bitte beachten Sie: Die Durchsuchen-Funktion steht nur auf Servern zur Verfügung, dieWebDAV und Microsoft SharePoint Server unterstützen. Die unterstützten Protokollesind FTP, HTTP und HTTPS.
Damit Sie mehr Kontrolle über den Ladevorgang haben, können Sie auswählen, ob dieDatei über den lokalen Cache-Speicher oder über einen Proxy-Server (wodurch derLadevorgang 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 Siez.B. mit einem EPS oder einem Datenbanksystem arbeiten; wählen Sie in diesem Falldie Option Neu laden.
Anmerkungen zu Microsoft® SharePoint® ServerBeachten 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 derDatei (Eingecheckt/Ausgecheckt) kennzeichnen.
© 2017 Altova GmbH
Datei 399Menüreferenz
Altova UModel 2017
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 undkann nicht ausgecheckt werden.
Lokal ausgecheckt. Die Datei kann bearbeitet und eingechecktwerden.
Nachdem Sie eine Datei ausgecheckt haben, können Sie sie in Ihrer Altova-Applikationbearbeiten und mit Datei | Speichern (Strg+S) speichern.Sie können die bearbeitete Datei über das Kontextmenü im Dialogfeld "URL öffnen" (sieheAbbildung oben) einchecken.
Wenn eine Datei von einem anderen Benutzer ausgecheckt wurde, kann sie nichtauscheckt werden.Wenn eine Datei lokal von Ihnen ausgecheckt wurde, können Sie dies mit demKontextmenübefehl "Auschecken rückgängig" rückgängig machen. In diesem Fall wirddie Datei dem Server unverändert zurückgegeben.Wenn Sie eine Datei in einer Altova-Applikation auschecken, können Sie sie in eineranderen Altova-Applikation nicht auschecken. Die Datei gilt bereits als für Sieausgecheckt. Daher stehen in diesem Fall in jeder Altova-Applikation, die Microsoft®SharePoint® Server unterstützt, nur die Befehle Einchecken und Auscheckenrückgängig zur Verfügung.
400 Menüreferenz Datei
© 2017 Altova GmbHAltova UModel 2017
Neu ladenDient zum Neuladen des aktuellen Projekts und zum Speichern oder Verwerfen der Änderungen,die seit dem letzten Öffnen der Projektdatei vorgenommen wurden.
SpeichernSpeichert das aktuell aktive Modellierungsprojekt unter dem aktiven Dateinamen.
Speichern unterSpeichert das aktuell aktive Modellierungsprojekt unter einem anderen Namen bzw. dient zumSpeichern des Projekts unter einem Namen, wenn Sie das Projekt zum ersten Mal speichern.
Kopie speichern unterDamit können Sie eine Kopie des aktuell aktiven UModel-Projekts unter einem anderenDateinamen speichern.
Diagramm als Bild speichernÖffnet das Dialogfeld "Speichern unter..." und speichert das aktuell aktive Diagramm je nach Wahlals .png- oder .emf (Enhanced Metafile)-Datei. Es können nun auch sehr große PNG-Dateien imGigabyte-Bereich gespeichert werden.
Alle Diagramme als Bilder speichernSpeichert alle Diagramme des derzeit aktiven Projekts als .png- oder .emf (enhanced metafile)-Datei.
Aus XMI-Datei importierenImportiert eine zuvor exportierte XMI-Datei. Wenn die Datei mit UModel erzeugt wurde, werden alleErweiterungen usw. beibehalten.
In XMI-Datei exportierenExportiert das Modell als XMI-Datei. Sie können die UML-Version sowie die zu exportierenden IDsauswä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.
© 2017 Altova GmbH
Datei 401Menüreferenz
Altova UModel 2017
Bei Auswahl der Option "Aktuelle" wird der aktuell definierte Zoomfaktor desModellierungsprojekts beibehalten und die Gruppe "Umbruch von Bildern" wird aktiviert.
Bei Auswahl der Option "Verhindern" wird verhindert, dass Modellelemente über Seiten hinwegumbrochen werden. Sie werden auf einer Seite angezeigt.
Bei Auswahl von "Optimale" wird das Modellierungsprojekt an die Seitengröße angepasst. Siekö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 UML-Diagramme.
DruckvorschauÖffnet dasselbe Druckdialogfeld mit denselben Einstellungen wie oben beschrieben.
DruckereinrichtungÖffnet das Dialogfeld "Druckereinrichtung", in dem Sie einstellen können, welchen Drucker undwelche Papiereinstellungen Sie verwenden möchten.
402 Menüreferenz Bearbeiten
© 2017 Altova GmbHAltova UModel 2017
14.2 Bearbeiten
Rückgängig UModel gestattet eine unbegrenzte Anzahl an Rückgängig-Schritten, sodass Sie IhrenModellierungsvorgang Schritt für Schritt zurückverfolgen können.
Wiederherstellen Mit Hilfe des Befehls "Wiederherstellen" können Sie zuvor rückgängig gemachte Befehlewiederholen. Sie können sich innerhalb des Verlaufs der rückgängig gemachten Schritte vorwärtsund rückwärts bewegen.
Ausschneiden/Kopieren/LöschenDie Windows-Standardbearbeitungsbefehle gestatten Ihnen, Modellelemente auszuschneiden, zukopieren, usw. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und Einfügenin UModel Diagramme.
EinfügenEntweder über die Tastenkürzel Strg+V, den Befehl "Einfügen" aus dem Kontextmenü oder demgleichnamigen Befehl aus dem Menü "Bearbeiten". Fügt immer ein neues Modellelement zumDiagramm und zur Modellstruktur hinzu. Nähere Informationen siehe "Ausschneiden, Kopierenund Einfügen in UModel Diagramme".
Nur in Diagramm einfügenBefehl, der über das Kontextmenü aufgerufen wird, d.h. durch Rechtsklick auf denDiagrammhintergrund. Fügt nur einen Link/eine Ansicht eines bestehenden Elements zumaktuellen Diagramm nicht aber zur Modell-Struktur hinzu. Nähere Informationen siehe"Ausschneiden, Kopieren und Einfügen in UModel Diagramme".
Nur aus Diagramm löschenLöscht die ausgewählten Modellelemente aus dem aktuell aktiven Diagramm. Die gelöschtenElemente 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 auseiner Klasse verfügbar ist. Eigenschaften oder Operationen können ausgewählt und direkt aus derKlasse gelöscht werden.
Alles markierenMarkiert alle Modellelemente des aktuell aktiven Diagramms. Entspricht der TastenkombinationStrg+A .
SuchenEs stehen verschiedene Optionen zum Suchen von Modellelementen zur Verfügung:
Über das Textfeld in der Titelleiste über die Menüoption Bearbeiten | SuchenDrücken Sie die Tastenkombination Strg+F um das Dialogfeld "Suchen" zu öffnen.
© 2017 Altova GmbH
Bearbeiten 403Menüreferenz
Altova UModel 2017
Dient zum Suchen von bestimmtem Text:
in einem der drei Modell-Strukturbereiche: Modell-Struktur, Diagramm-Struktur undFavoriten.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 imderzeit aktiven Diagramm.
Vorheriges suchen Umschalt+F3Sucht die vorherige Instanz desselben Suchstrings auf dem derzeit aktiven Register oder imderzeit aktiven Diagramm.
ErsetzenDient zum Suchen und Ersetzen eines beliebigen Modellierungselements im Projekt. Wenn dasElement gefunden wird, wird es sowohl im Diagramm als auch in der Modell-Struktur markiert.
Suchen und Ersetzen funktioniert in:
allen Diagrammenjedem der drei Modell-Struktur-Fenster: auf den Registern Modell-Struktur, Diagramm-Struktur und Favoriten.dem Register "Dokumentation" des Fensters "Übersicht".
404 Menüreferenz Bearbeiten
© 2017 Altova GmbHAltova UModel 2017
Als Bitmap kopierenKopiert das derzeit aktive Diagramm in die Zwischenablage, von wo aus Sie es in die ApplikationIhrer Wahl einfügen können.
Bitte beachten Sie:Diagramme werden in die System-Zwischenablage kopiert. Sie müssen sie in eine andereApplikation einfügen, um sie zu sehen oder darauf zugreifen zu können.
Auswahl als Bitmap kopierenKopiert die aktuell ausgewählten Diagrammelemente in die Zwischenablage, von wo aus Siesie in die Applikation Ihrer Wahl einfügen können.
© 2017 Altova GmbH
Projekt 405Menüreferenz
Altova UModel 2017
14.3 Projekt
Projektsyntax überprüfen...Überprüft die UModel-Projektsyntax. Die Projektdatei wird auf mehreren Ebenen überprüft. SieheTabelle 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 CodeEngineering verwenden" wird keine Überprüfungdurchgeführt und die Syntaxüberprüfung istdeaktiviert
Keine
Klasse ob der Name der Code-Datei definiert ist.
Wenn die Klasse geschachtelt ist, wird keineÜberprüfung durchgeführt.
Fehler, wenn dielokale Option"FehlendeCodedateinamengenerieren" nichtaktiviert wurde. Warnung, wenn dieOption aktiviert ist.
ob die Klasse in einem Codesprachen-Namespaceenthalten 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, nurwenn die Klasse nicht geschachtelt ist.
Warnung
Schnittstelle ob der Codedateiname definiert ist. Fehler, wenn dielokale Option"FehlendeCodedateinamengenerieren" nichtaktiviert ist. Warnung, wenn dieOption aktiviert ist.
ob die Schnittstelle in einem Codesprachen-Namespace enthalten ist
Fehler
ob der Typ für die Eigenschaften definiert ist Fehler
ob der Typ für den Operationsparameter definiert ist Fehler
406 Menüreferenz Projekt
© 2017 Altova GmbHAltova UModel 2017
ob der Rückgabetyp für die Operation definiert ist Fehler
überprüft auf doppelte Operationen (Namen +Parametertypen)
Fehler
ob Schnittstellen in einer Komponentenrealisierungvorkommen
Warnung
Enumeration Gehört zum Java Namespace Root:Gibt eine Warnung aus, dass kein Code generiertwird.
Warnung
Gehört nicht zur Java Namespace Root:Es wird keine Überprüfung durchgeführt und dieSyntaxüberprüfung ist für die Enumerationdeaktiviert. Es wird an dem enthaltenen Paket keineÜberprüfung durchgeführt
Keine
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
Klasseneigen-schaft
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Klassen-operation
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)Überprüft, ob Rückgabeparameter vorhanden sind
Fehler
Klassen-operations-parameter
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)Überprüft ob der Typ einen gültigen Java-Typnamen hat
Fehler
Schnittstelle Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Schnittstellen-operation
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Schnittstellen-operations-parameter
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Schnittstellen-eigenschaften
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Paket mitStereotyp-Namespace
Überprüft, ob der Name ein gültiger Java-Name ist(keine unzulässigen Zeichen, Name ist kein Keyword)
Fehler
Paket ohneStereotyp-Namespace
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 Java-Codegenerierung sind. Nähere Informationen dazu siehe "Einschränken vonModellelementen".
Versionskontrolle
© 2017 Altova GmbH
Projekt 407Menüreferenz
Altova UModel 2017
Nähere Informationen und Anleitungen zu Versionskontrollservern und Clients finden Sie unter Versionskontrolle.
Quellverzeichnis importieren...Öffnet das unten gezeigte Dialogfeld "Quellverzeichnis importieren". Ein Beispiel dazu finden Sieunter "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 Projekttypauswä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ärdateienimportieren können. Nähere Informationen dafür finden Sie unter "Importieren von Java-, C#- undVB-Binärdateien.
XML-Schemaverzeichnis importierenÖffnet das Dialogfeld "XML-Schemaverzeichnis importieren", über das Sie alle XML-Schemas indiesem Verzeichnis und optional dazu alle XML-Schemas in den Unterverzeichnissen diesesVerzeichnisses 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ählenkönnen, die die Basis für das generierte Sequenzdiagramm bilden sollen.
408 Menüreferenz Projekt
© 2017 Altova GmbHAltova UModel 2017
Nachdem Sie die Operationen ausgewählt und auf OK geklickt haben, wird das Dialogfeld"Sequenzdiagrammgenerierung" geöffnet, in dem Sie weitere Einstellungen zurDiagrammgenerierung 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 dieEinstellungen für die jeweilige Programmiersprache auswählen.
Mergen oder Überschreiben von CodeAngenommen, 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 wirddie neu hinzugefügte Klasse X aus UModel zum Code hinzugefügt wird.
© 2017 Altova GmbH
Projekt 409Menüreferenz
Altova UModel 2017
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 dieEinstellungen für die jeweilige Programmiersprache auswählen.
Mergen oder Überschreiben von CodeAngenommen, 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 wirddie 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 wirddie neu hinzugefügte Klasse Y aus externem Code zum Modell hinzugefügt wird.
410 Menüreferenz Projekt
© 2017 Altova GmbHAltova UModel 2017
ProjekteinstellungenGestattet Ihnen das Definieren von Einstellungen für bestimmte Programmiersprachen für IhrProjekt.
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, istdie Datei, in die die zweite Datei überführt wird. Nähere Informationen dazu finden Sie unter Zusammenführen von UModel-Projekten.
© 2017 Altova GmbH
Projekt 411Menüreferenz
Altova UModel 2017
Unterprojekt inkludierenSiehe Inkludieren anderer UMdoel-Projekte.
Unterprojekt als Projekt öffnenÖffnet das ausgewählte Unterprojekt als neues Projekt.
Meldungen löschenLöscht die Meldungen, Warnungen und Fehler, die im Fenster "Meldungen" zurSyntaxüberprüfung und Codezusammenführung angezeigt werden.
Bitte beachten Sie:Fehlermeldungen weisen im Allgemeinen auf Probleme hin, die vor der Codegenerierung bzw. vorder Aktualisierung des Modellcodes während der Codegenerierung behoben werden müssen.Warnmeldungen weisen im Allgemeinen auf Probleme hin, die auch später behoben werdenkönnen. Fehlermeldungen und Warnmeldungen werden von der Syntaxüberprüfung, dem Compilerfür die spezifische Sprache, dem UModel Parser, der die neu generierte Quelldatei liest, sowiebeim Import von XMI-Dateien, generiert.
Dokumentation generierenGestattet die Generierung von Dokumentation in den Formaten HTML, Microsoft Word und RTFfür das derzeit offene Projekt. Nähere Informationen dazu finden Sie unter Generieren von UML-Dokumentation.
In keinem Diagramm verwendete Elemente auflistenErstellt eine Liste aller Elemente, die in keinem Diagramm des Projekts verwendet werden.
Freigegebene Pakete auflistenListet alle freigegebenen Pakete des aktuellen Projekts auf.
Inkludierte Pakete auflistenListet 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.
412 Menüreferenz Layout
© 2017 Altova GmbHAltova UModel 2017
14.4 Layout
Die Befehle des Menüs "Layout" gestatten Ihnen, die Elemente Ihrer Modelldiagrammeanzuordnen und aneinander auszurichten.
Bei Verwendung der Marquee-Technik (Aufziehen eines Rechtecks über dem Diagramm) zurMarkierung mehrerer Elemente wird das Element mit der strichlierten Umrandung, d.h. das zuletztmarkierte Element, zum "aktiven" Element. Bei allen Befehle zum Ausrichten wird diesesElement als Ursprungselement verwendet, anhand dessen die folgenden Befehle ausgeführtwerden.
Ausrichten:Dieser Befehl dient je nach Auswahl des jeweiligen Befehls zum Ausrichten von Modellelementenentlang ihrer Ränder oder Mittelpunkte.
Gleichmäßig anordnen:Mit dieser Gruppe von Befehlen können Sie ausgewählte Elemente sowohl in horizontaler alsauch 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 desaktiven Elements anpassen.
Anordnen:Mit Hilfe dieser Gruppe von Befehlen können Sie die ausgewählten Elemente vertikal oderhorizontal in einer Linie anordnen.
Linienart:Mit Hilfe dieser Gruppe von Befehlen können Sie die Art der Linie auswählen, mit der dieverschiedenen Modellelemente verbunden werden sollen. Die Linien können jede Art vonAbhängigkeit oder Assoziation darstellen, die in den verschiedenen Diagrammen verwendetwerden.
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-Diagrammregisterdargestellt werden sollen.
Mit "Zentriert" werden die Modellelemente zentriert ausgerichtet.
Bei Auswahl von "Hierarchisch" werden die Elemente nach ihrer Beziehung, übergeordnetenKlasse, 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.
© 2017 Altova GmbH
Ansicht 413Menüreferenz
Altova UModel 2017
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- oderausblenden
den Zoomfaktor des aktuellen Diagramms definieren
414 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
14.6 Extras
Im Menü "Extras" können Sie:
Ihre Version anpassen: Ihre eigenen Symbolleisten, Tastaturkürzel, Menüs und Makrosdefinierendie globalen Programmeinstellungen/optionen definieren
14.6.1 Benutzerdefinierte Tools
Wenn Sie den Mauszeiger über den Befehl Benutzerdefinierte Tools platzieren, wird einUntermenü mit benutzerdefinierten Befehlen angezeigt, die externe Applikationen verwenden. Siekönnen diese Befehle im Dialogfeld "Anpassen" auf dem Register "Extras" erstellen. Wenn Sieauf einen dieser benutzerdefinierten Befehle klicken, wird die mit diesem Befehl verknüpfte Aktionausgefü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).
14.6.2 Anpassen...
Der Befehl "Anpassen" dient zum Anpassen von UModel an Ihre persönlichen Bedürfnisse.
BefehleSymbolleistenExtrasTastaturMenüOptionen
© 2017 Altova GmbH
Extras 415Menüreferenz
Altova UModel 2017
Befehle14.6.2.1
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 kleineSchaltfläche. Das Häkchen unterhalb des Mauszeigers bedeutet, dass der Befehl nichtan der aktuellen Cursorposition abgelegt werden kann.An den Stellen, an die der Befehl gezogen werden kann (also über der Symbolleiste odereinem Menü) verschwindet das Häkchen.Wenn Sie den Cursor beim Ziehen über ein Menü ziehen, wird dieses geöffnet, sodassSie den Befehl an einer beliebigen Stelle im Menü ablegen können.Befehle können in Menüs oder Symbolleisten platziert werden. Wenn Sie Ihre eigeneSymbolleiste 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 durchRechtsklick aufgerufen) bearbeiten. Klicken Sie auf das Register "Menü" und wählen Sieanschließ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.
Symbolleisten14.6.2.2
Auf dem Register "Symbolleisten" können Sie bestimmte Symbolleisten aktivieren oderdeaktivieren sowie Ihre eigenen Symbolleisten erstellen.
Symbolleisten enthalten Befehle für die am häufigsten verwendeten Menübefehle. Zu jedemSymbol erhalten Sie eine kurze Erklärung in Form eines Tooltipps, wenn Sie den Mauszeigerdirekt über das Element platzieren. In der Statusleiste wird eine detailliertere Beschreibung desBefehls angezeigt.
Sie können die Symbolleisten von ihrer Standardposition an eine beliebige Stelle auf demBildschirm ziehen, wo sie als abgedocktes Fenster angezeigt werden. Alternativ dazu können Siedie Symbolleisten auch am linken oder rechten Rand des Hauptfensters andocken.
416 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
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ückKlicken Sie auf den Menüleisteneintrag undanschließend auf die Schaltfläche Zurücksetzen, um die Menübefehle auf den Zustandzum Zeitpunkt der Installation zurückzusetzen
So setzen Sie alle Symbolleisten- und Menübefehle zurückKlicken Sie auf die Schaltfläche Alle zurücksetzen, um alle Symbolleistenbefehle aufden Zustand zum Zeitpunkt der Installation des Programms zurückzusetzen. Sie werdengefragt, 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.
Extras14.6.2.3
Über das Register "Extras" können Sie im Menü "Extras" Ihre eigenen Menüeinträge und damitverknü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üeintraghinzuzufügen und verknüpfen Sie ihn über das Feld "Befehl" mit einer Anwendung.
© 2017 Altova GmbH
Extras 417Menüreferenz
Altova UModel 2017
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übefehlgestartet 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.
418 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
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
ProjektdateinameDer Dateiname der aktiven UModel-Projektdatei, z.B. “Test.ump”.
ProjektdateipfadDer absolute Dateipfad der aktiven UModel-Projektdatei, z.B. “c:\MyDirectory\Test.ump”.
Fokussierte UML-Daten - NameDer Name des UML-Elements, das sich gerade im Fokus befindet, z.B. “Class1”.
Fokussierte UML-Daten - UML Qualified NameDer qualifizierte Name des UML-Elements, das sich gerade im Fokus befindet, z.B.“Package1::Package2::Class1”.
Fokussierte UML-Daten - CodedateinameDer 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 – CodedateipfadDer Codedateipfad der im Fenster "Eigenschaften" angegebenen UML-Klasse, Schnittstelle oderEnumeration die sich gerade im Fokus befindet, z.B. “C:\Temp\MySource\Class1.cs”.
© 2017 Altova GmbH
Extras 419Menüreferenz
Altova UModel 2017
Fokussierte UML-Daten – CodeprojektdateinameDer Dateiname des Codeprojekts, zu dem die gerade fokussierte UML-Klasse, Schnittstelle oderEnumeration gehört.
Der Codeprojektdateiname kann relativ zur UModel-Projektdatei angegeben werden und istderselbe, der auch in den Eigenschaften der Komponenten angezeigt wird, z.B. “C:\Temp\MySource\MyProject.vcproj” or “MySource\MyProject.vcproj”.
Fokussierte UML-Daten - CodeprojektdateipfadDer Dateipfad des Codeprojekts, zu dem die gerade fokussierte UML-Klasse, Schnittstelle oderEnumeration gehört, z.B. “C:\Temp\MySource\MyProject.vcproj”.
Tastatur14.6.2.4
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 Tastenkombinationbereits zugewiesen wurde, so wird diese Funktion unterhalb des Textfelds angezeigt.
4. Klicken Sie auf die Schaltfläche Zuweisen, um das Tastaturkürzel permanentzuzuweisen.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ü14.6.2.5
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
420 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
Wahl.
So löschen Sie Befehle aus einem Menü:1. Rechtsklicken Sie auf den Befehl oder das Symbol für den Befehl und2. Wählen Sie die Option Löschen aus dem Popup-Menü aus.
oder1. Wählen Sie Extras | Anpassen, um das Dialogfeld "Anpassen" zu öffnen und2. 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 und2. 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 und2. Wählen Sie im Popup-Menü die Option Löschen aus.
oder,1. Wählen Sie Extras | Anpassen, um das Dialogfeld "Anpassen" zu öffnen und2. 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 und2. 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 oder2. Klicken Sie im Dialogfeld "Anpassen" auf die Schaltfläche "Schließen".
MenüschattenKlicken Sie auf das Kontrollkästchen "Menüschatten", wenn die Menüs mit Schattenangezeigt werden sollen.
Optionen14.6.2.6
Auf dem Register "Optionen" können Sie allgemeine Einstellungen vornehmen.
Wenn das Kontrollkästchen Tooltip in Symbolleiste einblenden aktiv ist, wird ein Tooltippangezeigt, wenn der Mauszeiger über eine Symbolleisten-Schaltfläche platziert wird. In diesemTooltipp wird eine kurze Beschreibung der Schaltflächenfunktion sowie das dazugehörigeTastaturkürzel, falls eines zugewiesen wurde, angezeigt.
© 2017 Altova GmbH
Extras 421Menüreferenz
Altova UModel 2017
Wenn das Kontrollkästchen Große Symbole aktiv ist, werden anstatt der Standardsymbolegrößere Symbole angezeigt.
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 zubestätigen
Dieser Befehl ist hilfreich, wenn Sie Symbolleisten oder Fenster verschoben oder ausgeblendetoder deren Größe angepasst haben und nun alle Originaleinstellungen wiederherstellen möchten.
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 Applikationstitelleistedie Elementarten, die aufgelistet werden sollen, wenn Sie auf dem Register "Model-Struktur" oder "Favoriten" auf die Kontextmenüoption "In keinem Diagramm verwendeteElemente auflisten" klicken. Sie haben auch die Möglichkeit, Elemente in inkludiertenDateien zu ignorieren.ob ein in einem Diagramm ausgewähltes Element in der Modell-Struktur automatischausgewählt/synchronisiert werden soll.die Standardtiefe der hierarchischen Ansicht auf dem Register "Hierarchie" beiVerwendung der Option Graph. Ansicht anzeigen .Die Einstellungen für automatisches hierarchisches Layout, über Sie für dasHierarchiefenster die Verschachtelungstiefe nach oben und unten festlegen können."Jedes Element nur einmal erweitern". Dadurch kann im selben Bild/Diagramm kann nureines derselben Classifier-Elemente erweitert werden.ob Sie Elemente beim Ziehen mit der Maus in einem Diagramm an Hilfslinien ausrichtenmöchten.
422 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
Auf dem Register Bearbeiten können Sie folgende Einstellungen definieren:
Ob ein neues auf dem Register "Modell-Struktur" erstelltes Diagramm im Hauptfensterautomatisch geöffnet werden soll.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 hierlöschen, kann diese Eingabeaufforderung deaktiviert werden. Sie können dieEingabeaufforderung "vor dem Löschen fragen" hier zurücksetzen.Die Zeit nach der Syntaxfehler-Popup-Fenster geschlossen werden sollen.
© 2017 Altova GmbH
Extras 423Menüreferenz
Altova UModel 2017
424 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
Auf dem Register Diagrammbearbeitung können Sie folgende Einstellungen definieren:wie viele Objekte automatisch zu einem Diagramm hinzugefügt werden können, bevoreine Eingabeaufforderung erscheint.die Anzeige von Stilen, wenn diese automatisch zu einem Diagramm hinzugefügt werden.ob automatisch Assoziationen zwischen Modellelementen erstellt werden sollen, wennElemente 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 qualifiziertaufgelö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 dieVorlage diesen Namespace hat, erstellt UModel automatisch eine Collection-Assoziation.Ausnahme: Wenn die Vorlage zum Paket der unbekannten externen Elemente gehörtund 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 Operationenim 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 demaktuellen Projekt geladen und gespeichert werden soll.ob das zuletzt geöffnete Projekt beim Starten der Applikation automatisch geöffnetwerden soll.ob die Projektdatei mit CR/LF-Zeilen und Tabulatoreinrückungen im Pretty-Print-Format
© 2017 Altova GmbH
Extras 425Menüreferenz
Altova UModel 2017
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 Rootenthalten 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 Engineeringverwendet werden, d.h. Elemente, bei denen das Kontrollkästchen "für CodeEngineering 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 sollenob im Codedateipfad Namespaces verwendet werden sollen
Die im Code verwendete Einrückungsmethode, d.h. Tabulatoren oder beliebig vieleLeerzeichen
welche Verzeichnisse beim Aktualisieren eines UModel-Projekts anhand von Code odereinem Verzeichnis ignoriert werden sollen. Trennen Sie die einzelnen Verzeichnissedurch ein Semikolon ";". Untergeordnete Verzeichnisse desselben Namens werdenebenfalls ignoriert.
den Pfad zur XMLSpy-Datei RootCatalog.xml, welche es UModel sowie XMLSpyerlaubt, allgemein verwendete Schemas (sowie Stylesheets und andere Dateien) auslokalen Benutzerordnern aufzurufen. Dadurch wird die allgemeineVerarbeitungsgeschwindigkeit erhöht und Benutzer können auf diese Art auch offlinearbeiten.
426 Menüreferenz Extras
© 2017 Altova GmbHAltova UModel 2017
© 2017 Altova GmbH
Extras 427Menüreferenz
Altova UModel 2017
Auf dem Register Versionskontrolle können Sie folgende Einstellungen vornehmen:
Auswahl des aktuellen Versionskontroll-Plug-in über die Auswahlliste. Über dieSchaltfläche "Erweitert" können Sie die genauen Einstellungen für das ausgewählteVersionskontroll-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 Dialogfelderdie Option "Wenn Dialogfelder mit "..nicht mehr anzeigen" ausgeblendet waren, klickenSie auf "Zurücksetzen", damit sie wieder angezeigt werden" aktiviert haben. Daraufhinwird diese "nicht mehr anzeigen"-Meldung wieder angezeigt.
428 Menüreferenz Fenster
© 2017 Altova GmbHAltova UModel 2017
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 unterenRands 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ächstenHyperlink-Element.
Vorheriges:Wechselt zum vorherigen Modelldiagrammregister in der Reihe der Register oder zum vorherigenHyperlink-Element.
Fensterliste:In dieser Liste werden alle derzeit offenen Fenster angezeigt, sodass Sie zwischen ihnenwechseln können.
Sie können auch mit Hilfe der Tastaturkürzel Strg-TAB oder Strg F6 zwischen den offenenFenstern hin- und herwechseln.
© 2017 Altova GmbH
Hilfe 429Menüreferenz
Altova UModel 2017
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 angezeigtwird. Das Inhaltsverzeichnis bietet eine Übersicht über das gesamte Hilfedokument.Wenn Sie auf einen Eintrag im Inhaltsverzeichnis klicken, gelangen Sie zu diesemThema.
Index� � Beschreibung
Mit dem Befehl Index wird die Bildschirmhilfe für UModel geöffnet, wobei auf der linkenSeite des Hilfefensters der Stichwortindex angezeigt wird. Im Index werden Stichwörteraufgelistet und Sie können durch Doppelklick auf das Stichwort zum jeweiligen Themanavigieren. Wenn ein Stichwort mit mehr als einem Thema verknüpft ist, können Sie dasThema aus einer Liste von Themen auswählen.
Suchen� � Beschreibung
Mit dem Befehl Suchen wird die Bildschirmhilfe für UModel geöffnet, wobei auf derlinken Seite des Hilfefensters das Suchdialogfeld angezeigt wird. Um nach einem Begriffzu 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 gibteine Trefferliste zurück. Doppelklicken Sie auf einen Eintrag, um das Themaanzuzeigen.
Software-Aktivierung
Beschreibung
Nachdem Sie Ihre Altova-Software heruntergeladen haben, können Sie sie entweder mitHilfe eines kostenlosen Evaluierungs-Keycode oder eines käuflich erworbenenpermanenten Lizenzkeycode aktivieren.
Kostenloser Evaluierungs-Keycode. Wenn Sie die Software zum ersten Malstarten, wird das Dialogfeld "Software-Aktivierung" angezeigt. Es enthält eine
430 Menüreferenz Hilfe
© 2017 Altova GmbHAltova UModel 2017
Schaltfläche, über die Sie einen kostenlosen Evaluierungs-Keycode anfordernkönnen. Geben Sie in das Dialogfeld, das daraufhin angezeigt wird, IhrenNamen, den Namen Ihrer Firma und Ihre E-Mail-Adresse ein und klicken Sie auf"Jetzt anfordern!". Der Evaluierungs-Keycode wird an die von Ihnen angegebeneE-Mail-Adresse gesendet und sollte in wenigen Minuten eintreffen. Geben Sieden Schlüssel nun im Dialogfeld "Software-Aktivierung" in das Feld Key-Codeein und klicken Sie auf OK, um Ihr Altova-Produkt zu aktivieren. Die Softwarewird für einen Zeitraum von 30 Tagen aktiviert.Permanenter Lizenz Keycode. Das Dialogfeld "Software-Aktivierung" enthälteine Schaltfläche, über die Sie einen permanenten Lizenz-Keycode erwerbenkönnen. Wenn Sie auf diese Schaltfläche klicken, gelangen Sie zum AltovaOnline Shop, wo Sie einen permanenten Lizenz-Keycode für Ihr Produkterwerben können. Bei Ihrem permanenten Lizenz-Keycode handelt es sichentweder um eine Einzelbenutzerlizenz oder um eine Mehrfachlizenz. BeideArten werden per E-Mail zugesandt. Eine Einzelbenutzerlizenz enthält IhreLizenzdaten, Ihren Namen, die Firma, E-Mail-Adresse und Keycode. Eine Mehrfachlizenz enthält Ihre Lizenzdaten, ihren Firmennamen und denKeycode. Beachten Sie, dass gemäß Ihrer Lizenzvereinbarung auf denComputern Ihres Unternehmens nur so viele Versionen der Altova-Softwareinstalliert werden dürfen, wie lizenziert wurden (Mehrplatzlizenz).
Anmerkung: Stellen Sie bitte sicher, dass die von Ihnen in das Registrierungsdialogfeldeingegebenen Daten genau mit denen in Ihrer Lizenz-E-Mail übereinstimmen. GebenSie außerdem bei Mehrplatzlizenzen den Namen des jeweiligen Benutzers in das Feld"Name" ein.
Das Dialogfeld "Software-Aktivierung" (Abbildung unten) kann jederzeit über den BefehlHilfe | Software-Aktivierung aufgerufen werden.
Sie können die Software auf die folgenden Arten aktivieren:
durch Eingabe der Lizenzschlüsselinformationen (Klicken Sie auf NeuenKeycode eingeben) oder durch Abruf einer Lizenz über einen Altova LicenseServer auf Ihrem Netzwerk(klicken Sie um unteren Rand des Dialogfelds "Software-Aktivierung" auf AltovaLicenseServer verwenden). Der Altova LicenseServer muss in seinemLizenzpool eine Lizenz für Ihre Altova-Produkt haben. Wenn im LicenceServer-Pool eine Lizenz verfügbar ist, wird dies im Dialogfeld "Software-Aktivierung"angezeigt (Abbildung unten) und Sie können auf Speichern klicken, um dieLizenz abzurufen.
© 2017 Altova GmbH
Hilfe 431Menüreferenz
Altova UModel 2017
Beachten Sie, dass eine Lizenz erst sieben Tage nach Abruf dieser Lizenzwieder an den LicenseServer zurückgegeben werden kann. Sobald die Lizenzdurch Klick auf Lizenz zurückgeben an den Server zurückgegeben wurde,kann sie von einem anderen Client abgerufen werden.
Lizenz-Check-OutÜber den Lizenzpool können Sie eine Lizenz für einen Zeitraum von bis zu 30Tagen auschecken, sodass die Lizenz auf dem lokalen Rechner gespeichertwird. Dadurch können Sie offline arbeiten, was nützlich ist, wenn Sie z.B. ineiner Umgebung arbeiten möchten, in der Sie keinen Zugriff auf Ihren AltovaLicenseServer haben (z.B. wenn Ihr Altova-Produkt auf einem Laptop installiertist und Sie gerade unterwegs sind). Solange die Lizenz ausgecheckt ist, zeigtLicenseServer die Lizenz als in Verwendung an. Diese Lizenz kann dann vonkeinem anderen Rechner verwendet werden. Die Lizenz wird nach Ablauf desCheck-Out-Zeitraums automatisch wieder eingecheckt. Alternativ dazu kanneine ausgecheckte Lizenz jederzeit über die Schaltfläche Einchecken desDialogfelds "Software-Aktivierung" wieder eingecheckt werden.
Um eine Lizenz auszuchecken, gehen Sie folgendermaßen vor: (i) Klicken Sieim Dialogfeld "Software-Aktivierung" auf Lizenz auschecken (siehe Abbildungoben); (ii) Wählen Sie im daraufhin angezeigten Dialogfeld "Lizenz-Check-Out"den gewünschten Check-Out-Zeitraum aus und klicken Sie auf Auschecken.Daraufhin wird die Lizenz ausgecheckt. Die Check-Out-Informationen und dasEnde des Check-Out-Zeitraums werden im Dialogfeld "Software-Aktivierung"angezeigt. Die Schaltfläche Lizenz auschecken im Dialogfeld ändert sich nunin Einchecken. Sie können die Lizenz jederzeit durch Klicken auf Eincheckeneinchecken. Da die Lizenz automatisch wieder in den Zustand Eingechecktzurück wechselt, sollte der von Ihnen ausgewählte Zeitraum für das Check-Outden gewünschten Zeitraum, in dem Sie offline arbeiten möchten, entsprechendabdecken.
432 Menüreferenz Hilfe
© 2017 Altova GmbHAltova UModel 2017
Anmerkung: Damit Lizenzen ausgecheckt werden können, muss dieseFunktion auf dem LicenseServer aktiviert werden. Wenn diese Funktion nichtaktiviert wurde, erhalten Sie eine entsprechende Fehlermeldung. Wenden Siesich in diesem Fall an Ihren LicenseServer-Administrator.
Altova LicenseServer bietet IT-Administratoren einen Echtzeitüberblick über alle Altova-Lizenzen in einem Netzwerk. Dazu werden die Einzelheiten zu jeder Lizenz sowieClient-Zuweisungen und die Verwendung von Lizenzen durch Clients angezeigt. DerVorteil der Verwendung von LicenseServer liegt in seinen Funktionen zur Verwaltunggroßer Altova-Lizenzpools. Altova LicenseServer steht kostenlos auf der Altova Websitezur Verfügung. Nähere Informationen zu Altova LicenseServer und der Lizenzierungmittels Altova LicenseServer finden Sie in der Dokumentation zu Altova LicenseServer.
Bestellformular
Beschreibung
Sobald Sie eine lizenzierte Version des Software-Produkts bestellen möchten, klickenSie im Dialogfeld "Software-Aktivierung" (siehe oben) auf die SchaltflächePermanenten Key-Code erwerben... im zum sicheren Online-Shop von Altovaweitergeleitet zu werden.
Registrierung� Beschreibung
Bei Aufruf dieses Befehls wird die Altova-Produktregistrierungsseite auf einem RegisterIhres 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 undzeigt eine entsprechende Meldung an.
Support Center� �
© 2017 Altova GmbH
Hilfe 433Menüreferenz
Altova UModel 2017
Beschreibung
Der Befehl Support Center ist ein Link zum Altova Support Center im Internet. ImSupport Center finden Sie Antworten auf häufig gestellt Fragen, Diskussionsforen, indenen Sie Software-Probleme besprechen können und ein Formular, um unsereMitarbeiter vom technischen Support zu kontaktieren.
Fragen und Antworten im Web� � Beschreibung
Der Befehl Fragen und Antworten im Web ist ein Link zur Altova-Fragen- undAntworten-Datenbank im Internet. Diese Datenbank wird ständig aktualisiert, wenn dieMitarbeiter 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 Anbieterherunterladen, die Sie mit Altova Produkten verwenden können. Dabei handelt es sichum XSLT- und XSL-FO-Prozessoren, Applikationsserverplattformen usw. Die imKomponenten Download Center verfügbare Software ist normalerweise kostenlos.
UModel im Internet� � Beschreibung
Der Befehl UModel im Internet ist ein Link zur Altova Website im Internet. Hiererfahren Sie mehr über UModel und verwandte Technologien und Produkte auf derAltova Website.
Über UModel� � Beschreibung
Mit dem Befehl Über UModel wird das Willkommensfenster und die VersionsnummerIhres Produkts angezeigt. Wenn Sie die 64-Bit-Verson von UModel verwenden, wird dies
434 Menüreferenz Hilfe
© 2017 Altova GmbHAltova UModel 2017
durch das Suffix (x64) nach dem Applikationsnamen angezeigt. Die 32-Bit-Version hatkein Suffix.
Kapitel 15
Code Generator
436 Code Generator
© 2017 Altova GmbHAltova UModel 2017
15 Code Generator
UModel enthält einen integrierten Codegenerator, der automatisch Java-, C#, Visual Basic oderXML-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 Siejetzt auswählen, ob der Alias aufgelöst werden soll (Kontrollkästchen "Aliasse auflösen" imDialogfeld "Quellprojekt/Verzeichnis importieren").
Beim Aktualisieren von Code, d.h. wenn der Code anhand des Modells aktualisiert wird, werdenwieder die korrekten Aliasdefinitionen verwendet. Der Geltungsbereich der Aliasdefinitionen sinddie 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 "unbekanntenexternen 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.
© 2017 Altova GmbH
SPL (Spy Programming Language) 437Code Generator
Altova UModel 2017
15.1 SPL (Spy Programming Language)
In diesem Abschnitt erhalten Sie eine Übersicht über Spy Programming Language (SPL), dieTemplate-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 verwendeterobjektorientierter 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 UModelbereitgestellte Objektmodell. Die Vorlagendateien enthalten SPL-Anweisungen zum Erstellen vonDateien, Lesen von Informationen aus dem Objektmodell und Ausführen von Berechnungen, die inder Zielprogrammiersprache auch Literalcodefragmente enthalten.
Die Vorlagendatei wird von Code Generator interpretiert und je nach Vorlage wird eine .java, .cs-Quellcodedatei oder eine andere Dateiart ausgegeben.
15.1.1 Grundlegende SPL-Struktur
Eine SPL-Datei enthält Literaltext, der ausgegeben werden soll, der zwischendurch CodeGenerator-Anweisungen enthält.
Code Generator-Anweisungen sind in eckige Klammern eingeschlossen '[' und ']'. Innerhalb einerKlammer können mehrere Anweisungen stehen. Zusätzliche Anweisungen müssen durch eineneue 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 DateienText, der nicht innerhalb von [ und ] steht, wird direkt in die Ausgabedatei geschrieben. Um eckige Klammern als Literale auszugeben, setzen Sie davor als Excape-Zeichen einenumgekehrten Schrägstrich: \[ und \]. Um einen umgekehrten Schrägstrich auszugeben,verwenden Sie \\.
KommentareKommentare innerhalb eines Anweisungsblocks beginnen immer mit einem ' Zeichen und endenan der nächsten Zeile oder an einem Zeichen, zum Beenden eines Blocks ].
438 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
15.1.2 Variablen
Jede etwas komplexere SPL-Datei enthält Variablen. Einige Variablen sind vom Code Generatorvordefiniert. Sie können jederzeit neue Variablen erstellen, indem Sie diesen Werte zuweisen.
Das $-Zeichen wird zur Deklarierung oder Verwendung einer Variablen verwendet. Vor derVariable muss immer ein $ stehen. Bei Variablennamen muss die Groß- und Kleinschreibungbeachtet werden.
Variablentypen: Integer - wird auch als Boolescher Wert verwendet, wobei 0 false ist und alle anderenWerte true.StringObjekt - wird von UModel bereitgestelltIterator (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 doppeltenAnführungszeichen stehen. \n und \t innerhalb von doppelten Anführungszeichen werden als neueZeile und Tabulator interpretiert, \" ist ein literales doppeltes Anführungszeichen und \\ ist einumgekehrter Schrägstrich. String-Konstanten können auch mehrere Zeilen einnehmen.
Bei der Verkettung von Strings wird das & Zeichen verwendet.
[$BasePath = $outputpath & "/" & $JavaPackageDir]
ObjekteObjekte 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 neuenObjekte erstellt werden (sie werden durch den Code Generator vordefiniert, aus der Input-Komponente 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 demWert der Eigenschaft Name des Objekts $class.
In der folgenden Tabelle sehen Sie die Beziehung zwischen UML-Elementen und ihren SPL-Entsprechungen sowie eine kurze Beschreibung dazu.
© 2017 Altova GmbH
SPL (Spy Programming Language) 439Code Generator
Altova UModel 2017
Vordefinierte Variablen
UML-Element SPL-
Eigenschaft
Multiplizit
ät
UML UModel Beschreibung
Attribute /
Association
Attribute /
Association
BehavioralFeature isAbstract isAbstract:Boolean
BehavioralFeature raisedExcepti
on
* raisedException:Type
BehavioralFeature ow nedParam
eter
* ow nedParameter:Para
meter
BehavioredClassif
ier
interfaceReali
zation
* interfaceRealization:Int
erfaceRealization
Class ow nedOperat
ion
* ow nedOperation:Oper
ation
Class nestedClassif
ier
* nestedClassifier:Classi
fier
Classifier namespace * namespace:Packag
e
packages w ith code
language
<<namespace>> set
Classifier rootNamespa
ce
* project root
namespace:String
VB only - root
namespace
Classifier generalization * generalization:Generali
zation
Classifier isAbstract isAbstract:Boolean
ClassifierTemplate
Parameter
constrainingC
lassifier
* constrainingClassifier
Comment body body:String
DataType ow nedAttribu
te
* ow nedAttribute:Proper
ty
DataType ow nedOperat
ion
* ow nedOperation:Oper
ation
Element kind kind:String
Element ow ner 0..1 ow ner:Element
Element appliedStereo
type
* appliedStereotype:S
tereotypeApplicatio
n
applied stereotypes
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
440 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
EnumerationLiteral nestedClassif
ier
* nestedClassifier:Cla
ssifier
Feature isStatic isStatic:Boolean
Generalization general 1 general:Classifier
Interface ow nedAttribu
te
* ow nedAttribute:Proper
ty
Interface ow nedOperat
ion
* ow nedOperation:Oper
ation
Interface nestedClassif
ier
* nestedClassifier:Classi
fier
InterfaceRealizatio
n
contract 1 contract:Interface
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 visibility <public>
NamedElement isProtected isProtected:Boolean visibility <protected>
NamedElement isPrivate isPrivate:Boolean visibility <private>
NamedElement isPackage isPackage:Boolean visibility <package>
NamedElement namespacePr
efix
namespacePrefix:St
ring
XSD only - namespace
prefix w hen exists
NamedElement parseableNa
me
parseableName:Stri
ng
CSharp, VB only - name
w ith escaped
keyw ords (@)
Namespace elementImport * elementImport:ElementI
mport
Operation ow nedReturn
Parameter
0..1 ow nedReturnParam
eter:Parameter
parameter w ith direction
return set
Operation type 0..1 type type of parameter w ith
direction return set
Operation ow nedOperat
ionParameter
* ow nedOperationPar
ameter:Parameter
all parameters excluding
parameter w ith direction
return set
Operation implementedIn
terface
1 implementedInterfac
e:Interface
CSharp only - the
implemented interface
Operation ow nedOperat
ionImplementa
tions
* implementedOperati
on:OperationImplem
entation
VB only - the
implemented interfaces/
operations
OperationImpleme
ntation
implementedO
perationOw n
er
1 implementedOperati
onOw ner:Interface
interface implemented
by the operation
OperationImpleme
ntation
implementedO
perationName
name:String name of the
implemented operation
OperationImpleme
ntation
implementedO
perationParse
ableName
parseableName:Stri
ng
name of the
implemented operation
w ith esacped
keyw ords
© 2017 Altova GmbH
SPL (Spy Programming Language) 441Code Generator
Altova UModel 2017
Package namespace * namespace:Packag
e
packages w ith code
language
<<namespace>> set
PackageableEleme
nt
ow ningPacka
ge
0..1 ow ningPackage set if ow ner is a
package
PackageableEleme
nt
ow ningName
spacePackag
e
0..1 ow ningNamespace
Package:Package
ow ning package w ith
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
n
true if parameter is a
variable argument list
Parameter defaultValue 0..1 defaultValue:ValueSp
ecification
Property defaultValue 0..1 defaultValue:ValueSp
ecification
RedefinableEleme
nt
isLeaf isLeaf:Boolean
Slot name name:String name of the defining
feature
Slot values * value:ValueSpecificati
on
Slot value value:String value of the first value
specification
StereotypeApplica
tion
name name:String name of applied
stereotype
StereotypeApplica
tion
taggedValue * taggedValue:Slot first slot of the instance
specification
StructuralFeature isReadOnly isReadOnly
StructuredClassifi
er
ow nedAttribu
te
* ow nedAttribute:Proper
ty
TemplateBinding signature 1 signature:TemplateSig
nature
TemplateBinding parameterSu
bstitution
* parameterSubstitution:
TemplateParameterSu
bstitution
TemplateParamete
r
paramDefault paramDefault:String template parameter
default value
TemplateParamete
r
ow nedParam
eteredElemen
t
1 ow nedParameteredEle
ment:ParameterableEle
ment
TemplateParamete
rSubstitution
parameterSu
bstitution
parameterSubstituti
on:String
Java only - code
w ildcard handling
TemplateParamete
rSubstitution
parameterDim
ensionCount
parameterDimension
Count:Integer
code dimension count
of the actual parameter
TemplateParamete
rSubstitution
actual 1 Ow nedActual:Paramet
erableElement
442 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
TemplateParamete
rSubstitution
formal 1 formal:TemplateParam
eter
TemplateSignature template 1 template:Templateable
Element
TemplateSignature ow nedParam
eter
* ow nedParameter:Tem
plateParameter
TemplateableElem
ent
isTemplate isTemplate:Boolean true if template
signature set
TemplateableElem
ent
ow nedTempl
ateSignature
0..1 ow nedTemplateSignat
ure:TemplateSignature
TemplateableElem
ent
templateBindi
ng
* templateBinding:Templ
ateBinding
Type typeName * typeName:Packagea
bleElement
qualified code type
names
TypedElement type 0..1 type:Type
TypedElement postTypeModi
fier
postTypeModifier:St
ring
postfix code modifiers
ValueSpecificatio
n
value value:String string value of the value
specification
Hinzufügen eines Präfixes zu Attributen einer Klasse bei der CodegenerierungEventuell 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 dieSchreibweise 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 Codesaktualisieren, 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. oberhalbdes 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 Siebitte sicher, dass Sie im Dialogfeld "Synchronisierungseinstellungen" auf dem Register Code vonModell das Kontrollkästchen "Benutzerdefinierte setzt Standardvorlage außer Kraft" aktivierthaben.
SPL-VorlagenSPL-Vorlagen können über die Menüoption Projekt | Projekteinstellungen (siehe Abbildungunten) pro UModel-Projekt definiert werden. Auch relative Pfade werden unterstützt. Vorlagen, dieim angegebenen Verzeichnis nicht gefunden werden, werden im lokalen Standard-Verzeichnisgesucht.
© 2017 Altova GmbH
SPL (Spy Programming Language) 443Code Generator
Altova UModel 2017
Globale Objekte
$Options ein Objekt, das globale Optionen enthält:
generateComments:bool doc-Kommentare generieren (true/false)
$Indent ein String zum Einrücken von generiertem Code und zur Anzeige deraktuellen Verschachtelungsebene.
$IndentStep ein String zum Einrücken von generiertem Code und zur Darstellungeiner Verschachtelungsebene.
$NamespacePrefix nur XSD – das Target Namespace Präfix, falls vorhanden
Routinen zur Behandlung von Stringsinteger Compare(s)Der Rückgabewert gibt die lexikographische Beziehung des String zu s an (unterBerü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 (ohneBerü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 gefundenwird.
444 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
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 sentspricht. string RemoveLeftNoCase( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Left( s.Length() ) dem Substring sentspricht (Groß- und Kleinschreibung wird ignoriert).
string RemoveRight( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substring sentspricht.
string RemoveRightNoCase( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substring sentspricht (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.
15.1.3 Operatoren
Operatoren in SPL funktionieren wie in den meisten anderen Programmiersprachen.
Liste von SPL-Operatoren absteigend nach Vorrangigkeit gereiht:
© 2017 Altova GmbH
SPL (Spy Programming Language) 445Code Generator
Altova UModel 2017
. Objekteigenschaft aufrufen( ) Gruppierung eines Ausdruckstrue Boolesche Konstante "true"false Boolesche Konstante "false"
& String-Verkettung
- Zeichen für negative Zahlnot Logische Negation
* Multiplizieren/ Dividieren% Modulo
+ Addieren- Subtrahieren
<= Kleiner oder gleich< Kleiner als>= Größer oder gleich> Größer als
= Gleich<> Nicht gleich
and Logische Konjunktion (mit short circuit-Auswertung)or Logische Disjunktion (mit short circuit-Auswertung)
= Zuweisung
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 undVergleichsoperatoren konstruiert.
Bedingungen:Wie bei jeder anderen Programmiersprache, werden Bedingungen mit logischen und
446 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
Vergleichsoperatoren erstellt:
Beispiel:[if $namespace.ContainsPublicClasses and $namespace.Prefix <> ""]
whatever you want ['inserts whatever you want, in the resulting file][endif]
SwitchSPL 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.
15.1.5 Collections und foreach
Collections und Iteratoren
Eine Collection enthält mehrere Objekte - wie ein gewöhnliches Array. Iteratoren lösen dasProblem 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 worknext]
Foreach iteriert durch alle Datenelemente in $classes und führt für die Anweisung den Code derauf die Anweisung folgt, bis zur nächsten Anweisung aus.
© 2017 Altova GmbH
SPL (Spy Programming Language) 447Code Generator
Altova UModel 2017
In jeder Iteration wird $class dem nächsten Klassenobjekt zugewiesen. Sie arbeiten einfach mitdem Klassenobjekt, anstelle classes[i]->class->Name(), zu verwenden, wie das in C++ der Fallwä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 (unterBerücksichtigung der Groß- und Kleinschreibung) nach Namen sortiert sind .
collection SortByNameNoCase( bAscending )gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge (ohneBerü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 nachkind-Namen (z.B. “Class”, “Interface”,…) sortiert sind.
collection SortByKindAndName( bAscendingKind, bAscendingName )gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge nach"kind" (z.B. “Class”, “Interface”,…) sortiert sind, wobei berücksichtigt wird, ob die "kinds" sortiertin aufsteigender oder absteigender Reihenfolge (unter Berücksichtigung der Groß- undKleinschreibung) im Namen identisch sind.
collection SortByKindAndNameNoCase( bAscending )gibt eine Collection zurück, deren Elemente in aufsteigender oder absteigender Reihenfolge nach"kind" (z.B. “Class”, “Interface”,…) sortiert sind, wobei berücksichtigt wird, ob die "kinds" sortiertin aufsteigender oder absteigender Reihenfolge (ohne Berücksichtigung der Groß- undKleinschreibung) im Namen identisch sind.
448 Code Generator SPL (Spy Programming Language)
© 2017 Altova GmbHAltova UModel 2017
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 ReferenzLokale/globale Parameter (lokal innerhalb von Subroutinen)Lokale VariablenRekursiver Aufruf (Subroutinen können sich selbst aufrufen)
Deklaration einer Subroutine15.1.6.1
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 nachdem Parameter.EndSub notiert das Ende des Code-Blocks.
Bitte beachten Sie:Eine rekursive oder kaskadierende Subroutine-Deklaration ist nicht zulässig, d.h. eineSubroutine darf keine weiteren Subroutinen enthalten.
ParameterParameter können auch durch Prozeduren unter Verwendung der folgenden Syntax übergebenwerden:
Alle Parameter müssen Variablen seinVariablen muss das $-Zeichen vorangestellt werdenLokale Variablen werden in einer Subroutine definiertGlobale Variablen werden explizit außerhalb von Subroutinen deklariertMehrere Parameter werden innerhalb runder Klammern durch Kommas "," voneinandergetrenntParameter können Werte übergeben
Parameter - Übergabe von WertenParameter können auf zwei Arten übergeben werden: nach Wert oder nach Referenz, wobei dieSchlüsselwörter ByVal bzw. ByRef verwendet werden.
© 2017 Altova GmbH
SPL (Spy Programming Language) 449Code Generator
Altova UModel 2017
Syntax:' define sub CompleteSub()[Sub CompleteSub( $param, ByVal $paramByValue, ByRef $paramByRef )] ...
ByVal definiert, dass der Parameter nach Wert übergeben wird. Beachten Sie, dass diemeisten Objekte nur nach Referenz übergeben werden können.ByRef definiert, dass der Parameter nach Referenz übergeben wird. Dies ist dieStandardeinstellung, wenn weder ByVal noch ByRef definiert ist.
FunktionsrückgabewerteFür die Rückgabe eines Werts von einer Subroutine verwenden Sie ein Return-Statement. Einesolche Funktion kann von innerhalb eines Ausdrucks aufgerufen werden.
Beispiel:' define a function[Sub MakeQualifiedName( ByVal $namespacePrefix, ByVal $localName )if $namespacePrefix = "" return $localNameelse return $namespacePrefix & ":" & $localNameendifEndSub]
Subroutinenaufruf15.1.6.2
Verwenden Sie zum Aufrufen einer Subroutine call, gefolgt vom Namen der Prozedur und ggf. denParametern.
Call SimpleSub()
oder,Call CompleteSub( "FirstParameter", $ParamByValue, $ParamByRef )
FunktionsaufrufUm eine Funktion (jede Subroutine, die ein Return-Statement enthält) aufzurufen, verwenden Sieeinfach deren Namen in einem Ausdruck. Verwenden Sie zum Aufrufen von Funktionen nicht das Call-Statement.Beispiel:$QName = MakeQualifiedName($namespace, "entry")
450 Code Generator Fehlercodes
© 2017 Altova GmbHAltova UModel 2017
15.2 Fehlercodes
Betriebssystem-Fehlercodes201 Datei nicht gefunden: '%s'202 Datei '%s' kann nicht erstellt werden203 Datei '%s' konnte nicht geöffnet werden204 Datei '%s' kann nicht in '%s' kopiert werden
Syntax-Fehlercodes401 Keyword erwartet402 '%s' erwartet403 Es wurde keine Output-Datei angegeben404 Unerwartetes Dateiende405 Keyword nicht zulässig
Runtime-Fehlercodes501 Unbekannte Variable '%s'502 Umdefinition der Variablen '%s'503 Variable '%s' ist kein Container504 Unbekannte Eigenschaft '%s'505 Kann %s nicht in %s konvertieren507 Unbekannte Funktion508 Funktion ist bereits definiert509 Ungültiger Parameter510 Division durch Null511 Unbekannte Methode512 Falsche Parameteranzahl513 Stapelüberlauf
Kapitel 16
Lizenzinformationen
452 Lizenzinformationen
© 2017 Altova GmbHAltova UModel 2017
16 Lizenzinformationen
Dieser Anhang enthält die folgenden Informationen:
Informationen über den Vertrieb dieses Software-ProduktsInformationen zur Software-Aktivierung und Lizenzüberwachung Informationen im Zusammenhang mit dem intellektuellen Eigentum dieses Software-Produktsdie Endbenutzer-Lizenzvereinbarung zu diesem Software-Produkt
Lesen Sie die Informationen bitte sorgfältig - sie sind rechtlich bindend, da Sie sich bei derInstallation dieses Software-Produkts damit einverstanden erklärt haben.
© 2017 Altova GmbH
Electronic Software Distribution 453Lizenzinformationen
Altova UModel 2017
16.1 Electronic Software Distribution
Dieses Produkt ist über EDS (Electronic Software Distribution), also auf elektronischem Wegerhä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 Bestellungonline abgeben und das Produkt steht Ihnen sofort im vollen Lizenzumfang zur Verfügung. Sie erhalten immer die neueste Version unserer SoftwareDie Software enthält ein umfassendes Online-Hilfesystem. Die neueste Version desBenutzerhandbuchs steht auf unserer Website www.altova.com (i) im HTML-Format zumAufrufen online und (ii) im PDF-Format zum Download und Ausdrucken zur Verfügung.
30-Tage-EvaluierungszeitraumNachdem Sie dieses Software-Produkt heruntergeladen haben, können Sie es 30 Tage langkostenlos testen. Während dieses Zeitraums werden Sie nach etwa 20 Tagen in regelmäßigenAbständen daran erinnert, dass die Software noch nicht lizenziert wurde. DieseErinnerungsmeldung wird allerdings nur einmal, nämlich bei jedem Start des Programms,angezeigt. Wenn Sie das Programm nach Ablauf des 30-tägigen Evaluierungszeitraumsweiterverwenden möchten, müssen Sie eine Altova Software-Lizenz erwerben, die Sie in Formeines 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 AltovaShop erwerben.
Weitergabe der Software an andere Mitarbeiter in Ihrem Unternehmen zu TestzweckenWenn 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 installierenmöchten, der nicht mit dem Internet verbunden ist, sollten Sie nur das Installationsprogrammweitergeben - vorausgesetzt es wurde nicht modifiziert. Jeder, der das von Ihnen zur Verfügunggestellte Installationsprogramm aufruft, muss einen eigenen Evaluierungs-Keycode für 30 Tageanfordern. Nach Ablauf des Testzeitraums, muss eine Lizenz erworben werden, damit dasProdukt weiter verwendet werden kann.
Nähere Informationen finden Sie in der Altova Software-Lizenzvereinbarung am Ende diesesHandbuchs.
454 Lizenzinformationen Software-Aktivierung und Lizenzüberwachung
© 2017 Altova GmbHAltova UModel 2017
16.2 Software-Aktivierung und Lizenzüberwachung
Im Rahmen der Aktivierung der Software durch Altova, verwendet die Software unter UmständenIhr internes Netzwerk und Ihre Internetverbindung, um die Lizenzdaten während der Installation,Registrierung, der Verwendung oder der Aktualisierung an einen von Altova betriebenenLizenzserver zu übertragen und die Authentizität der Lizenzdaten zu überprüfen, damit Altova-Software nicht ohne Lizenz oder auf unzulässige Art und Weise verwendet werden kann und umden Kundenservice gleichzeitig zu verbessern. Bei der Aktivierung werden zwischen IhremComputer und dem Altova-Lizenzserver für die Lizenzierung erforderliche Daten wie Informationenüber Betriebssystem, IP-Adresse, Datum/Uhrzeit, Software-Version und Computername sowieandere Informationen ausgetauscht.
Ihr Altova-Produkt verfügt über ein integriertes Lizenzüberwachungsmodul, das ebenfalls dazubeiträgt, unbeabsichtigte Verletzungen der Lizenzvereinbarung zu vermeiden. Ihr Produkt kannentweder mit einer Einzelplatzlizenz oder einer Mehrfachlizenz erworben werden. Je nach Lizenzstellt das Lizenzüberwachungsmodul sicher, dass nicht mehr als die lizenzierte Anzahl anBenutzern die Applikation gleichzeitig verwendet.
Bei dieser Lizenzüberwachungsmethode wird Ihr LAN-Netzwerk verwendet, um dieKommunikation zwischen Instanzen der Applikation, die auf verschiedenen Computern laufen, zuüberwachen.
EinzelplatzlizenzBeim Start der Applikation wird im Rahmen der Lizenzüberprüfung ein kurzes Broadcast-Datagramm abgesendet, um andere Instanzen des Produkts, die auf anderen Computern imselben Netzwerk laufen, zu finden. Wenn keine Antwort einlangt, wird ein Port geöffnet, derInformationen von anderen Instanzen der Applikation empfangen kann.
MehrfachlizenzWenn Sie im selben LAN mehrere Instanzen der Applikation verwenden, kommunizieren diesebeim Start kurz miteinander, um Keycode-Informationen auszutauschen, damit Sie sicher seinkönnen, dass nicht mehr als die lizenzierte Anzahl an Lizenzen gleichzeitig in Verwendung ist.Dieselbe Lizenzüberwachungstechnologie wird auch bei Unix und vielen anderenDatenbankentwicklungstools verwendet. Sie gestattet Benutzern den Erwerb von Parallellizenzenfür mehrere Benutzer zu vernünftigen Preisen.
Wir sind außerdem bestrebt, nur wenige, kleine Netzwerkpakete zu versenden, um Ihr Netzwerknicht zu überlasten. Die von Ihrem Altova Produkt verwendeten TCP/IP Ports (2799) sind offiziellbei IANA registriert, (nähere Informationen siehe IANA Website (http://www.iana.org/)) und unserLizenzü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 diesenNetzwerkverkehr zwischen verschiedenen Gruppen in Ihrem Unternehmen natürlich blockieren,
© 2017 Altova GmbH
Software-Aktivierung und Lizenzüberwachung 455Lizenzinformationen
Altova UModel 2017
solange Sie mit anderen Mitteln sicherstellen können, dass Ihre Lizenzvereinbarung eingehaltenwird.
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 derLizenzüberwachungsfunktion in Zusammenhang.
456 Lizenzinformationen Rechte am geistigen Eigentum
© 2017 Altova GmbHAltova UModel 2017
16.3 Rechte am geistigen Eigentum
Die Software und alle Kopien, deren Anfertigung Ihnen von Altova gestattet ist, sind das geistigeEigentum von Altova und dessen Lieferanten und stehen in deren Besitz. Struktur, Organisationund Code der Software stellen wertvolle Betriebsgeheimnisse und vertrauliche Informationen vonAltova und dessen Lieferanten dar. Die Software ist durch gesetzliche Bestimmungenurheberrechtlich geschützt. Diese gesetzlichen Bestimmungen beinhalten (ohne daraufbeschränkt zu sein) das Urheberrecht der Vereinigten Staaten, internationale Verträge und das inden Ländern, in denen die Software genutzt wird, geltende Recht. Altova behält sich dasEigentum an allen Patenten, Urheberrechten, Branchengeheimnissen, Warenzeichen undsonstigen geistigen Eigentumsrechten, die hinsichtlich der Software bestehen, vorbehält. DasEigentumsrecht von Altova erstreckt sich auch auf alle Bilder, Fotografien, Animationen, Videos,Audioaufzeichnungen, Musikstücke, Texte und „Applets“, die Teil der Software sind, und alledazugehörigen Unterlagen in gedruckter Form. Mitteilungen über geltend gemachte Verstößegegen geistige Eigentumsrechte sind an den Copyright Agenten von Altova zu richten (nähereAngaben dazu finden Sie auf der Website von Altova).
Altova Software enthält Software-Komponenten Dritter, die ebenfalls urheberrechtlich geschütztsind. 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.
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 457Lizenzinformationen
Altova UModel 2017
16.4 Altova Endbenutzer-Lizenzvereinbarung
DIES IST EIN RECHTSGÜLTIGES DOKUMENT -- BITTE BEWAHREN SIE ES SORGFÄLTIGAUF
ALTOVA® ENDBENUTZER-LIZENZVERTRAG
Lizenzgeber:Altova GmbHRudolfsplatz 13a/9A-1010 WienÖsterreich
Wichtig – Bitte sorgfältig lesen. Benutzerinformation:
Dieser Endbenutzer-Lizenzvertrag („Vertrag“) ist ein rechtsgültiger Vertrag, der zwischenIhnen und Altova GmbH („Altova“) abgeschlossen wurde. Bevor Sie die von Altovabereitgestellte Software („Software“) sowie die dazugehörige Dokumentation (u.a.Unterlagen in gedruckter Form, Online-Dateien oder Dokumentation in elektronischerForm („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 Siezu, dass Sie die Bedingungen dieses Vertrags sowie die Datenschutzbestimmungen(„Datenschutzbestimmungen“) von Altova, inklusive jedoch nicht ausschließlich dienachfolgend festgelegten Garantieausschlüsse, Haftungsbeschränkungen sowieDatennutzungs- und Kündigungsregelungen als rechtsverbindlich anerkennen, auchwenn Sie die Software nicht käuflich erwerben. Sie stimmen zu, dass dieseVereinbarung in demselben Umfang gültig und durchsetzbar ist, wie ein von Ihnenpersönlich unterzeichneter Vertrag. Wenn Sie den Bedingungen dieses Lizenzvertrags nichtzustimmen, sind Sie nicht zur Verwendung der Software berechtigt und müssen alleheruntergeladenen 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 IhrerZustimmung 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 derSoftware auf einem kompatiblen Einzelplatzrechner oder einer Workstation im selben LAN, wobeidie maximale Zahl an Computern, die im Lizenzumfang enthalten sind, nicht überschritten werdendarf. Vorbehaltlich der Beschränkungen gemäß Abschnitt 1 (c), dürfen Sie eine Kopie derSoftware auf mehr als einem Ihrer kompatiblen Einzelplatzrechnern oder Workstations installierenund verwenden, wenn Sie eine Named-User-Lizenz erworben haben. Vorbehaltlich derBeschränkungen gemäß den Abschnitten 1(d) und 1(e) darf die Software gleichzeitig im Netzwerkverwendet werden. Die maximale Zahl an Computern und/oder Benutzern sowie die Art derLizenz, d.h. Einzelplatzlizenz, Named-User-Lizenz oder Parallellizenz, wird beim Kauf derSoftware festgelegt und genau angegeben. Einzelplatzlizenzen sind als fixe Lizenzen und nicht
458 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
als Parallellizenzen zu verwenden, d.h. es ist nicht erlaubt, die Software auf einem Rechner zudeinstallieren, um sie auf einem anderen Rechner zu installieren und die Sofware anschließendwieder zu deinstallieren und wieder auf dem ursprünglichen Rechner zu installieren. DieInstallation sollte statisch sein. Dessen ungeachtet ist die Deinstallation und Neuinstallation ineinigen eingeschränkten Fällen, z.B. wenn ein Mitarbeiter das Unternehmen verlässt oder wennein Rechner ausgemustert wird, gestattet. Während des Evaluierungszeitraums (wie nachfolgenddefiniert) darf die Software nur von einem Benutzer und auf nur einem (1) Einzelplatzrechner odereiner Workstation installiert und genutzt werden. Wenn Sie die Lizenz im Rahmen eines Paketsvon Altova-Softwareprodukten („Produktpaket“) erworben haben, von denen Sie nicht jedesProdukt einzeln installiert haben, gelten die Bestimmungen dieses Vertrags für die Verwendungder gesamten Software, die im Lieferumfang des Produktpakets enthalten ist.
(ii) Wenn Sie eine Lizenz für SchemaAgent erworben haben, dann gelten dieBestimmungen dieses Lizenzvertrags zur Nutzung der Software für den darin inkludiertenSchemaAgent-Server („SchemaAgent-Server“). Dabei dürfen Sie den SchemaAgent-Server jedochausschließlich in Verbindung mit der Altova-Software und nur für die in der dazugehörigenDokumentation beschriebenen Zwecke verwenden.
(iii) Wenn Sie eine Lizenz für Software erworben haben, die es dem Benutzer ermöglichtden Quellcode zu generieren, dann sind Sie durch die Ihnen im Rahmen dieser Lizenz erteilteGenehmigung zur Installation und Verwendung der Software auch berechtigt, den Quellcode zugenerieren, 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 Quellmaterialsgenerierte Code wird als „unbeschränkter Quellcode“ bezeichnet). Zusätzlich zu den durch diesenLizenzvertrag eingeräumten Rechten gewährt Ihnen Altova eine nicht ausschließliche, nichtübertragbare und eingeschränkte Lizenz, den gesamten generierten Code (bestehend aus dembeschränkten und unbeschränkten Quellcode) in eine ausführbare Objektcodeform zu übersetzenund diese zu verwenden, zu kopieren, weiterzugeben oder zu lizenzieren. Sie sind nur dannbefugt, den beschränkten Quellcode in unkompilierter Form ab- oder weiterzugeben,weiterzulizenzieren, zu verkaufen oder an Dritte zu übertragen, wenn die betreffende Partei bereitsin Form eines gesonderten Lizenzvertrags mit Altova zur Verwendung des beschränktenQuellcodes berechtigt ist. Ungeachtet anderslautender Bestimmungen in diesem Lizenzvertragdürfen Sie die Altova-Library-Module oder den beschränkten Quellcode (oder sonstiges geistigesEigentum von Altova enthalten in oder in Verbindung mit den Altova- Library-Modulen oder dembeschränkten Quellcode) nicht in solcher Art und Weise weitergeben, in andere Softwareeinbetten, mit anderer Software verbinden oder auf andere Weise verwenden, die denbeschränkten Quellcode den Bestimmungen des „Copylefts“, der freien Software oder einer OpenSource Lizenz unterwerfen würde, welche die Offenlegung des beschränkten Quellcodes oder derAltova-Library- Module erforderlich machen würde. Ungeachtet anderslautender Bestimmungen indiesem Lizenzvertrag dürfen Sie die Software nicht verwenden, um ohne vorherige schriftlicheEinwilligung von Seiten Altovas andere Software-Programme zu entwickeln und zu vertreiben, dieeine direkte Konkurrenz zu Altova-Software oder einem Altova-Dienst darstellen. Altova behältsich alle übrigen Rechte an der Software vor. Bei den Bestandteilen von UModel, für die einReverse Engineering Ihres eigenen oder eines anderen Quellcodes, den Sie rechtmäßig erworbenhaben, zulässig ist, stellt eine solche Verwendung durch Sie keinen Verstoß gegen diesenLizenzvertrag dar. Soweit dies nicht in Abschnitt 1(j) ausdrücklich gestattet wird, ist ein ReverseEngineering 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 nichtvorhanden, in einen oder mehrere der durch den Endbenutzer jederzeit aufrufbaren Bildschirmeund (2) - in elektronischer und/oder gedruckter Form in die Dokumentation zu inkludieren: "Teile
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 459Lizenzinformationen
Altova UModel 2017
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(Copyright © 2007-2016 Altova GmbH (www.altova.com) stehen."
(b) Verwendung auf einem Server zur Installation und Verwendung vonSchemaAgent. Sie sind berechtigt, ein (1) Exemplar der Software auf einem Dateiserverausschließlich innerhalb Ihres internen Netzwerks zu installieren und von dort auf die maximaleZahl von betrieblich genutzten Computern innerhalb dieses Netzwerks, die in der Lizenzangegeben ist, herunterzuladen und zu installieren. Wenn Sie eine Lizenz für SchemaAgenterworben haben, können Sie SchemaAgent auf jedem Server oder jeder Workstation installierenund 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 einenBenutzer, der nicht unter einer gültigen Lizenz von Altova zur Verwendung dieses Exemplars derSoftware 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) kompatiblenEinzelplatzrechnern 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) Malgleichzeitig 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). WennSie eine Parallellizenz Software-Version erworben haben, können Sie die Software auf mehrerenkompatiblen und betrieblich genutzten Computern installieren, jedoch höchstens zehnmal (10-mal) die maximale Anzahl der Benutzer, vorausgesetzt, dass nur die maximale Zahl vonBenutzern die Software wirklich gleichzeitig nutzen sowie weiters vorausgesetzt, dass dieComputer, 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 alseinem Netzwerk verwendet werden soll, sind für jedes separate LAN (Local Area Network)separate Parallelbenutzerlizenzen erforderlich, wobei die Einschränkungen hinsichtlich dermaximalen Zahl der Benutzer und der Anzahl der Nutzer, die die Software benutzen, anwendbarsind. Für den Fall, dass ein Computer nicht in dasselbe LAN (Local Area Network) eingebundenist, ist für diesen eine lokal installierte Benutzerlizenz oder eine Parallellizenz für die Verwendungin einer virtuellen Umgebung erforderlich.
(e) Parallellizenz für die Verwendung in einer virtuellen Umgebung. Wenn Sie eineParallellizenz erworben haben, sind Sie berechtigt, ein Exemplar der Software auf einem einzigenTerminalserver (Microsoft Terminal Server oder Citrix Metaframe), einemAnwendungsvirtualisierungsserver (Microsoft App-V, Citrix XenApp oder VMWare ThinApp) odereiner virtuellen Maschine in Ihrem Intranet zu installieren, damit einzelne Benutzer in IhrerOrganisation von einem anderen Computer über einen Terminalserver, einenAnwendungsvirtualisierungsserver oder eine virtuelle Maschine auf die Software zugreifen unddiese nutzen können. Jedoch darf die Zahl der Benutzer, die über einen solchen Netzwerk- oderTerminalserver bzw. eine virtuelle Maschine zum selben Zeitpunkt auf die Software zugreifen, diemaximale Zahl der im Lizenzumfang enthaltenen User nicht überschreiten. Außerdem darf dieGesamtanzahl der Benutzer, die die Software über den Terminal Server, denAnwendungsvirtualisierungsserver oder eine virtuelle Maschine verwenden, die zehn (10)-facheAnzahl der lizenzierten Benutzer nicht übersteigen. Parallellizenz-Freischaltcodes können nicht
460 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
auf mehr als einem Host Terminal Server, Anwendungsvirtualisierungsserver oder einer virtuellenMaschine bereitgestellt werden. Sie müssen mit Hilfe geeigneter Maßnahmen sicherstellen,dass nicht mehr als die maximale Anzahl der in der Lizenz vorgesehenen Benutzer gleichzeitigauf die Software zugreifen. Altova gibt über die Performance der Altova-Software in einerUmgebung, in der Terminalserver oder virtuelle Maschinen verwendet werden, keinerleiZusicherungen oder Gewährleistungen ab. Die Anwendung der Altova-Software auf die vorstehendbeschriebene Weise ist ausdrücklich von der eingeschränkten Garantie, die durch Abschnitt 5dieses Lizenzvertrags eingeräumt wird, ausgeschlossen. Ebenso wird kein technischer Supportbei 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 derSoftware für Sicherungs- und eine Kopie für Archivierungszwecke herstellen, sofern diese nicht aufeinem Computer installiert oder verwendet werden. Außerdem müssen bei Kopien zu Sicherungs-und Archivierungszwecken alle im Original enthaltenen urheber- und patentrechtlichen Angabensowie alle anderen Angaben hinsichtlich geistiger Eigentumsrechte von Ihnen reproduziert werdenund in der jeweiligen Kopie der Software unverändert enthalten sein. Die Befugnis zum Anlegeneiner Sicherungs- und Archivierungskopie darf nur an Dritte übertragen werden, wenn gleichzeitigeine Übertragung aller Rechte an der Software gemäß Abschnitt 3 erfolgt.
(g) Freischaltcodes, Upgrades und Updates. Bevor Sie die Software kaufen bzw. imRahmen Ihrer Registrierung für den Evaluierungszeitraum von dreißig (30) Tagen erhalten Sieeinen Evaluierungs-Freischaltcode. Wenn Sie sich in der Folge dazu entscheiden, die Softwarevon Altova GmbH oder einem autorisierten Vertriebshändler zu kaufen, erhalten Sie einenuneingeschränkten Freischaltcode. Mit diesem können Sie die Software nach demEvaluierungszeitraum aktivieren. Ohne ausdrückliche schriftliche Genehmigung von Altova dürfenSie an Freischaltcodes keine Lizenzen einräumen und Freischaltcodes nicht reproduzieren odervertreiben. Wenn die von Ihnen in Lizenz erworbene Software ein Upgrade oder Update ist, ersetztdas Upgrade oder Update das sie zuletzt heruntergeladen oder installiert haben, die zuvorlizenzierte Kopie der Software. Durch das betreffende Upgrade oder Update und dendazugehörigen Freischaltcode wird keine zweite Lizenz für die Software gewährt, und Sie dürfendie Kopie des Upgrades oder Updates nicht zusätzlich zu der Kopie der Software verwenden, diedadurch ersetzt wird und dessen Lizenz beendet wurde.
(h) Eigentumsrecht. Das Eigentumsrecht an der Software wird Ihnen nicht übertragen. AlleExemplare der Software und alle von Ihnen angefertigte Kopien verbleiben – vorbehaltlich der Ihnendurch 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 VertragsIhr Eigentum außer diese wurden mit einer Testsoftware gemäß Abschnitt 4 dieser Vereinbarungerstellt. In diesem Fall wird Ihnen nur eine beschränkte Lizenz zur Nutzung sämtlicherErgebnisse, welche einen generierten Programmcode (inklusive eines unbeschränktenQuellcodes) enthalten, wie Java, C++, C#, VB.NET oder XSLT und verbundene Projektdateien undBuild Scripts sowie generierte XML, XML Schematas, Dokumentationen, UML Diagrammen undDatenbankstrukturen, für die 30 Tage dauernde Testperiode eingeräumt.
(i) Reverse Engineering. Sofern dies nicht ausdrücklich nach geltendem Recht derEuropäischen Union gestattet ist, sind Sie nicht berechtigt, an der Software Reverse Engineeringdurchzuführen, die Software zu dekompilieren, zu disassemblieren, oder auf andere Weise zuversuchen, den Quellcode, zugrunde liegende Konzepte, Techniken für Benutzerschnittstellenoder Algorithmen der Software direkt oder indirekt zu entschlüsseln. Davon ausgenommen istlediglich das ausdrücklich nach geltendem Recht der Europäischen Union gestattete Maß anDekompilierung, das erforderlich ist, um die Funktionsfähigkeit der Software mit anderen
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 461Lizenzinformationen
Altova UModel 2017
Softwareprogrammen zu erzielen. Dies ist Ihnen jedoch erst dann gestattet, wenn Sie zuerst beiAltova die dafür notwendigen Informationen angefordert haben und Altova Ihnen diese nicht zurVerfügung gestellt hat. Altova ist berechtigt, für die Bereitstellung solcher Informationenangemessene Bedingungen aufzustellen und eine angemessene Entschädigung zu verlangen. Dievon Altova zur Verfügung gestellten Informationen bzw. alle von Ihnen im Sinne der hierfestgelegten Bestimmungen rechtmäßig erworbenen Informationen dürfen nur zu den hierinangeführten Zwecken verwendet und keinesfalls an Dritte weitergegeben oder zur Entwicklung vonSoftware genutzt werden, die der Software, die Gegenstand dieses Lizenzvertrags ist, inwesentlichen Aspekten ähnlich ist. Informationen im Sinne dieses Absatzes können vonBenutzern aus der Europäischen Union bei der Kundendienstabteilung von Altova angefordertwerden.
(j) Sonstige Beschränkungen. Sie sind nicht berechtigt, die Software (zur Gänze oderteilweise) 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 dieBestimmungen in Abschnitt 3 oder an anderer Stelle in diesem Lizenzvertrag ausdrücklichgestattet. Sofern dies nicht ausdrücklich in diesem Vertrag gestattet ist, dürfen Sie die Softwarenicht kopieren. Alle Kopien, zu deren Anfertigung Sie berechtigt sind, müssen die im Originalenthaltenen urheber- und patentrechtlichen Angaben sowie alle anderen Angaben hinsichtlichgeistiger 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 derSoftware bestellen oder die Bestellung eines solchen zulassen. Es ist Ihnen nicht gestattet,wissentlich eine Handlung vorzunehmen, durch die die Software öffentlich zugänglich wird, oderdie Software in einer Computerumgebung zu verwenden, die nicht in diesem Vertrag angegebenist. Die Verwendung oder der Zugriff auf die Software durch Dritte im Zusammenhang mit einerkommerziellen Dienstleistung wie z.B. für eine Cloud-basierte oder webbasierte SaaS-Verwendung ist nicht gestattet.
Sie haben die geltenden gesetzlichen Bestimmungen und die Anweisungen von Altova inBezug auf die Benutzung der Software einzuhalten. Sie sind verpflichtet, Ihre Mitarbeiter undVertreter, die Zugriff auf die Software haben, von den in diesem Vertrag enthaltenenBeschränkungen in Kenntnis zu setzen und diese auf sie zu überbinden.
(k) KEINE GARANTIE. ES WIRD KEINE GARANTIE ODER GEWÄHRLEISTUNG FÜR DIEFEHLERFREIHEIT DER SOFTWARE ABGEGEBEN ODER GEWÄHRT UND VON ALTOVAKEINERLEI HAFTUNG DIESBEZÜGLICH ÜBERNOMMEN. UNABHÄNGIG VONIRGENDWELCHEN SUPPORTLEISTUNGEN NACH IRGENDEINEM TECHNISCHEN STANDARDIST DIE SOFTWARE KEINESFALLS FÜR DIE VERWENDUNG IN ODER IM ZUSAMMENHANGMIT KERNKRAFTANLAGEN, FLUGGERÄTENAVIGATION, KOMMUNIKATIONSSYSTEMENODER LUFTVERKEHRSKONTROLLEINRICHTUNGEN, MEDIZINISCHEN GERÄTEN ODERLEBENSERHALTUNGSSYSTEMEN, MEDIZINISCHEN ODER DIE GESUNDHEITSVORSORGEBETREFFENDEN ANWENDUNGEN, ODER SONSTIGEN ANWENDUNGEN KONZIPIERT, BEIDENEN FEHLER DER SOFTWARE ODER FEHLER BEI DER DATENVERARBEITUNG ZUTODESFÄLLEN, PERSONENSCHÄDEN ODER SCHWEREN SACH- ODER UMWELTSCHÄDENFÜHREN KÖNNTEN. SIE ERKLÄREN SICH DAMIT EINVERSTANDEN, DASS SIE DIEALLEINIGE VERANTWORTUNG FÜR DIE EIGNUNG UND ZWECKMÄSSIGKEIT DERSOFTWARE UND ALLE MIT DER SOFTWARE ERSTELLTEN ODER VERARBEITETEN DATENFÜR DEN BEABSICHTIGTEN VERWENDUNGSZWECK TRAGEN UND SIE WERDEN ALTOVAUND DEREN GESCHÄFTSFÜHRER SOWIE ANGESTELLTE HINSICHTLICH ALLERANSPRÜCHE, FORDERUNGEN UND KLAGEN DRITTER, DIE AUF DIE EIGNUNG UNDZWECKMÄSSIGKEIT DER VON IHNEN VERWENDETEN SOFTWARE ODER DIE VON DERSOFTWARE ERSTELLTEN DATEN GEGRÜNDET SIND, SCHAD- UND KLAGLOS HALTEN.
462 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
2. GEISTIGE EIGENTUMSRECHTE
Die Software und alle Kopien, deren Anfertigung Ihnen von Altova gestattet ist, sind das geistigeEigentum von Altova und dessen Lieferanten und stehen in deren Besitz. Struktur, Organisationund Code der Software stellen wertvolle Betriebsgeheimnisse und vertrauliche Informationen vonAltova und dessen Lieferanten dar. Die Software ist durch gesetzliche Bestimmungenurheberrechtlich geschützt. Diese gesetzlichen Bestimmungen beinhalten (ohne daraufbeschränkt zu sein) das Urheberrecht der Vereinigten Staaten, internationale Verträge und das inden Ländern, in denen die Software genutzt wird, geltende Recht. Sie anerkennen, dass sichAltova das Eigentum an allen Patenten, Urheberrechten, Branchengeheimnissen, Warenzeichenund sonstigen geistigen Eigentumsrechten, die hinsichtlich der Software bestehen, vorbehält. DasEigentumsrecht von Altova erstreckt sich auch auf alle Bilder, Fotografien, Animationen, Videos,Audioaufzeichnungen, Musikstücke, Texte und „Applets“, die Teil der Software sind, und alledazugehörigen Unterlagen in gedruckter Form. Sie dürfen keine Handlungen vornehmen, die sichnachteilig auf die geistigen Eigentumsrechte von Altova an der Software auswirken. Warenzeichendürfen nur in Übereinstimmung mit den anerkannten Standards für die Verwendung vonWarenzeichen (einschließlich der namentlichen Nennung der Warenzeicheninhaber) verwendetwerden. Die Verwendung von Warenzeichen ist nur zur Kennzeichnung von Druckmaterialien, diemit der Software hergestellt wurden, gestattet. Es entstehen Ihnen daraus keinerleiEigentumsrechte an dem betreffenden Warenzeichen. Altova®, XMLSpy®, Authentic®,StyleVision®, MapForce®, UModel®, DatabaseSpy®, DiffDog®, SchemaAgent®,SemanticWorks®, MissionKit®, Markup Your Mind®, Nanonull™, RaptorXML™, RaptorXMLServer™, RaptorXML +XBRL Server™, Powered By RaptorXML™, FlowForce Server™,StyleVision Server™ und MapForce Server™ sind (in mehreren Ländern eingetragene oderangemeldete) Warenzeichen der Altova GmbH. Unicode und das Logo von Unicode sindWarenzeichen von Unicode, Inc. Windows, Windows XP, Windows Vista, Windows 7 undWindows 8 sind Warenzeichen von Microsoft. W3C, CSS, DOM, MathML, RDF, XHTML, XML undXSL 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 AltovaXMLSoftware. Mitteilungen über geltend gemachte Verstöße gegen geistige Eigentumsrechte sind anden Copyright Agent von Altova zu richten (nähere Angaben dazu finden Sie auf der Website vonAltova).
3. ÜBERTRAGUNGSBESCHRÄNKUNG
Ungeachtet der vorstehenden Bestimmungen dürfen Sie alle Ihre Rechte zur Verwendung derSoftware 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 derSoftware, die Gegenstand dieses Vertrags ist, geliefert, verpackt oder auf dieser vorinstalliert ist,einschließlich aller Kopien, Updates und früherer Versionen sowie aller Exemplare vonFontsoftware, die in andere Formate konvertiert wurde, an die betreffende Person übertragen; (b)Sie keine Kopien, einschließlich Sicherungskopien und sonstiger, auf einem Computergespeicherter Kopien, zurückbehalten; (c) der Empfänger von Altova einen persönlichenFreischaltcode von Altova erhält; und (d) der Empfänger die Bestimmungen dieses Vertrags sowiealle anderen Bestimmungen akzeptiert, zu denen Sie die Softwarelizenz rechtmäßig erworbenhaben. Ungeachtet der vorstehenden Ausführungen dürfen Sie keine Schulungs-, Vorab- oderMusterkopien 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
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 463Lizenzinformationen
Altova UModel 2017
Vorabversion oder um Beta-Software („Pre-Release-Software“) handelt, gelten die in diesemAbschnitt enthaltenen Bedingungen. Diese gelten außerdem für alle Test- und/oderDemoversionen von Altova-Software („Testsoftware“) und bleiben so lange gültig, bis Sie eineLizenz erwerben. Wenn Bestimmungen dieses Abschnitts im Widerspruch zu anderen, in diesemVertrag enthaltenen Bestimmungen stehen, dann gehen die Bedingungen dieses Abschnittshinsichtlich Pre-Release-Software und Testsoftware allen anderen Bestimmungen diesesLizenzvertrags vor, soweit dies für die Auflösung des Widerspruchs erforderlich ist. Sie erkennenan, dass es sich bei der Pre-Release-Software um eine Vorabversion handelt, die nicht dasendgültige Produkt von Altova darstellt, und in der Fehler, Funktionsstörungen oder andereProbleme auftreten können, die möglicherweise zu einem System- oder Hardwareabsturz oder -fehler bzw. zu Datenverlust führen. DIE PRE-RELEASE-SOFTWARE UND/ODERTESTSOFTWARE WIRD IHNEN DAHER OHNE GEWÄHR FÜR DEREN VERWENDUNG ODERLEISTUNGSMERKMALE ZUR VERFÜGUNG GESTELLT, UND ALTOVA ÜBERNIMMTDIESBEZÜGLICH KEINERLEI AUSDRÜCKLICHE ODER STILLSCHWEIGENDEGEWÄHRLEISTUNGS- ODER HAFTUNGSVERPFLICHTUNGEN. SOFERN UND SOWEIT FÜRPRE-RELEASE- UND/ODER TESTSOFTWARE KEIN HAFTUNGSSAUSSCHLUSS, SONDERNNUR EINE HAFTUNGSBESCHRÄNKUNG GESETZLICH ZULÄSSIG IST, BESCHRÄNKT SICHDIE HAFTUNG VON ALTOVA UND DESSEN LIEFERANTEN AUF INSGESAMT FÜNFZIG US-DOLLAR (50 USD). Wenn die Testversion mit einer Time-out-Funktion ausgestattet ist, kann sienach Ablauf des Evaluierungszeitraums nicht mehr verwendet werden. Mit dem Ablauf diesesZeitraums endet Ihre Lizenz automatisch, wenn Sie sie nicht verlängern. Ihre Lizenz zur Nutzungsämtlicher mit der Testsoftware erstellten Ergebnisse, welche einen generierten Progammcode(inklusive den unbeschränkten Quellcode) wie Java, C++, C#, VB.NET oder XSLT und verbundeneProjektdateien und Build Scripts sowie generierte XML, XML Schematas, Dokumentationen, UMLDiagramme und Datenbankstrukturen enthalten, erlischt automatisch nach Ablauf dervorgesehenen Testperiode. Die Lizenz zum Gebrauch dieser Ergebnisse lebt nach dem Kauf einerLizenz 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-Release-Software zu einem späteren Zeitpunkt anderen Personen anzukündigen oder zur Verfügung zustellen. Sie bestätigen ferner, dass Altova sich Ihnen gegenüber weder ausdrücklich nochstillschweigend verpflichtet hat, die Pre-Release-Software öffentlich anzukündigen odereinzuführen, und dass Altova kein Produkt anbieten muss, das der Pre-Release-Software ähnlichoder mit ihr kompatibel ist. Sie bestätigen folglich, dass jegliche Forschungs- oderEntwicklungsarbeit, die Sie in Bezug auf die Pre-Release-Software oder damit verbundeneProdukte ausführen, in Ihr alleiniges Risiko fällt. Wenn Altova Sie dazu auffordert, werden Sie fürdie Dauer dieses Vertrags Altova Rückmeldung bezüglich Ihrer Tests und der Pre-Release-Software geben, einschließlich entsprechender Berichte über Fehler und Funktionsstörungen.Wenn Sie die Pre-Release-Software im Rahmen einer gesonderten schriftlichen Vereinbarungerhalten haben, unterliegt Ihre Verwendung der Software den darin enthaltenen Bedingungen. Esist Ihnen nicht gestattet, die Pre-Release-Software unterzulizenzieren, per Leasing zur Verfügungzu 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 Pre-Release-Software bzw. bei Erhalt einer kommerziellen Vollversion von Altova (entweder alsEinzelprodukt oder als Teil eines Gesamtprodukts) die zuvor von Altova erhaltene Pre-Release-Software zurückzugeben oder zu vernichten und den Bestimmungen des Lizenzvertrags für diebetreffende 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 derPerson/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
464 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
neunzig (90) Tagen nach Erhalt im Wesentlichen in Übereinstimmung mit der dazugehörigenDokumentation funktioniert, und (ii) die von Altova zur Verfügung gestellten Supportleistungen imWesentlichen auf die in Abschnitt 6 dieses Vertrags niedergelegte Weise erfolgen. In einigenLändern sind Beschränkungen über die Dauer einer stillschweigenden Garantie nicht zulässig, sodass die obigen Beschränkungen und Ausschlüsse eventuell für Sie nicht zutreffen. Imgrößtmöglichen rechtlich zulässigen Maß sind stillschweigende Garantien in Bezug auf dieSoftware (sofern solche existieren) auf neunzig (90) Tage beschränkt. Die gesamte Haftung vonAltova und dessen Lieferanten, sowie Ihre einzigen Garantieansprüche, sind nach dem Ermessenvon 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änkteGarantie von Altova fällt und die unter Vorlage einer Kopie des Kaufbelegs bei Altova reklamiertwird. Diese eingeschränkte Garantie gilt nicht, wenn die Funktionalität der Software durch einVersehen, durch Missbrauch, falsche Anwendung, Trojaner, Viren oder einen sonstigenschädlichen externen Code beeinträchtigt wurde. Die Garantie für jede Ersatzsoftware erstrecktsich auf die Restdauer des ursprünglichen Garantiezeitraums oder auf dreißig (30) Tage, jenachdem, welcher Zeitraum länger ist. Die eingeschränkte Garantie gilt nicht für Test- und/oderPre-Release-Software.
(b) Keine weiteren Garantien, Haftungsausschluss. MIT AUSNAHME DERVORSTEHEND ANGEFÜHRTEN EINGESCHRÄNKTEN GARANTIE UND DENDIESBEZÜGLICHEN GARANTIEANSPRÜCHEN BESTEHEN SEITENS ALTOVA ODERDESSEN LIEFERANTEN KEINERLEI WEITEREN GARANTIEVERPFLICHTUNGEN. ALTOVAUND DESSEN LIEFERANTEN ÜBERNEHMEN KEINE GEWÄHR FÜR DIE ANWENDUNG ODERDIE ERGEBNISSE AUS DER NUTZUNG DER SOFTWARE. MIT AUSNAHME DERVORSTEHEND ANGEFÜHRTEN EINGESCHRÄNKTEN GARANTIE SOWIE IM HINBLICK AUFALLE ANDEREN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN ODERANSPRÜCHE, DIE NACH DER FÜR IHR LAND GELTENDEN RECHTSORDNUNG NICHTAUSGESCHLOSSEN ODER EINGESCHRÄNKT WERDEN KÖNNEN, SCHLIESSEN ALTOVAUND DESSEN LIEFERANTEN ALLE ANDEREN AUSDRÜCKLICHEN ODERSTILLSCHWEIGENDEN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN UNDANSPRÜCHE AUS, DIE SICH AUS DEM GESETZ, DER RECHTSPRAXIS, EINEMGEWOHNHEITSRECHT, EINEM HANDELSBRAUCH ODER AUS SONSTIGEN GRÜNDENERGEBEN. ALTOVA UND DESSEN LIEFERANTEN SCHLIESSEN IM GRÖSSTMÖGLICHENRECHTLICH ZULÄSSIGEN UMFANG ALLE ANDEREN AUSDRÜCKLICHEN UNDSTILLSCHWEIGENDEN GARANTIEN UND GEWÄHRLEISTUNGEN AUS. DIES BEINHALTETUNTER ANDEREM GARANTIEN IM HINBLICK AUF MARKTGÄNGIGKEIT, EIGNUNG FÜREINEN BESTIMMTEN ZWECK, ZUFRIEDENSTELLENDE QUALITÄT, INFORMATIONSGEHALTODER –RICHTIGKEIT, UNGESTÖRTE NUTZUNG, EIGENTUMSRECHT UNDNICHTVERLETZUNG VON RECHTEN DRITTER UND DIE ERBRINGUNG ODERNICHTERBRINGUNG VON SUPPORTLEISTUNGEN IN BEZUG AUF DIE SOFTWARE. MITDIESER EINGESCHRÄNKTEN GARANTIE WERDEN IHNEN BESTIMMTE RECHTEEINGERÄUMT. UNTER UMSTÄNDEN BESITZEN SIE NOCH ANDERE RECHTE; DIE JA NACHLAND/RECHTSORDNUNG UNTERSCHIEDLICH SEIN KÖNNEN.
(c) Haftungseinschränkung. SOWEIT DIE ANWENDBAREN GESETZE DIES ZULASSEN,HAFTEN ALTOVA ODER DESSEN LIEFERANTEN, AUCH WENN EINE IM RAHMEN DERGARANTIE DURCHGEFÜHRTE ABHILFEMASSNAHME IHREN WESENTLICHEN ZWECKNICHT ERFÜLLT, IN KEINEM FALL FÜR KONKRETE, ZUFÄLLIG ENTSTANDENE,MITTELBARE, UNMITTELBARE ODER FOLGESCHÄDEN JEGLICHER ART (INSBESONDERESCHÄDEN AUS ENTGANGENEM GEWINN, GESCHÄFTSUNTERBRECHUNGEN, VERLUSTVON GESCHÄFTSINFORMATIONEN ODER ANDEREN FINANZIELLEN VERLUSTEN), DIEDURCH DIE NUTZUNG ODER DIE UNMÖGLICHKEIT DER NUTZUNG DER SOFTWARE ODERDIE NICHTERBRINGUNG VON SUPPORTLEISTUNGEN ENTSTANDEN SIND, SELBST WENN
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 465Lizenzinformationen
Altova UModel 2017
ALTOVA AUF DIE MÖGLICHKEIT EINES SOLCHEN SCHADENS HINGEWIESEN WURDE. IINJEDEM FALL IST DIE GESAMTHAFTUNG VON ALTOVA GEMÄSS DIESEM VERTRAG AUFDIE 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ädenauszuschließen oder zu beschränken, gilt die obige Einschränkung unter Umständen nicht fürSie. In solchen Ländern und Rechtsordnungen gilt die Beschränkung der Haftung durch Altova imgrößtmöglichen rechtlich zulässigen Umfang, und der Ausschluss bzw. die Beschränkung der indiesem Lizenzvertrag beinhalteten Garantien und Haftungen hat keine Auswirkung auf dieKonsumentenschutzrechte von Personen, die Waren auf andere Weise als im Zuge ihrergeschäftlichen Tätigkeit erwerben. Der vorstehende Haftungssauschluss/die vorstehendeHaftungsbeschränkung sind wesentliche Bestandteile des zwischen Ihnen und Altovaabgeschlossenen Vertrags.
(d) Ansprüche in Zusammenhang mit Urheberrechtsverletzungen. Altova wird Siegegenüber allen Forderungen, Prozessen oder Verfahren schad- und klaglos halten bzw. alleAnsprü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 sonstigesEigentumsrecht verletzt, das durch das Recht der Vereinigten Staaten oder der EuropäischenUnion geschützt ist (insgesamt als „Ansprüche“ bezeichnet). Dies erfolgt – soweit nichtausdrücklich etwas Anderes festgelegt ist – jedoch nur insoweit, als der betreffende Anspruchsich direkt aus der Verwendung der Software ergibt und nach Maßgabe der in Abschnitt 5 diesesVertrags 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 zukooperieren und Altova dabei zu unterstützen, ohne dass Sie dafür Kosten geltend machenkö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 dasRecht, für Sie einen Vergleich zu den von Altova für zweckmäßig erachteten Bedingungeneinzugehen). Sie können auf eigene Kosten einen Rechtsberater hinzuziehen und an denVerfahrens- oder Vergleichsverhandlungen teilnehmen. Altova kommt bis zu einer Höhe voninsgesamt maximal dem Kaufpreis der Software für die Schäden, Kosten und Anwaltsgebührenauf, zu deren Bezahlung Sie in Zusammenhang mit solchen Ansprüchen verpflichtet werden (oderdie Sie aufgrund eines Vergleichs zu entrichten haben), soweit diese nicht von einer Versicherungoder dritten Partei übernommen werden. Ist oder wird die Software Gegenstand von aufgrund einerUrheberrechtsverletzung vorgebrachten Ansprüchen, oder wird ihre Verwendung untersagt, oder istes nach Ansicht des Rechtsberaters von Altova wahrscheinlich, dass ein solcher Umstand eintritt,so wird Altova versuchen, eine Beilegung herbeizuführen, indem alle wirtschaftlich vertretbarenAnstrengungen unternommen werden, um die Software zu modifizieren oder eine Lizenz für dieweitere Verwendung der Software zu erwerben. Wenn es nach Ansicht des Rechtsberaters vonAltova nicht möglich ist, den bevorstehenden oder bereits vorgebrachten Anspruch bzw. dieVerfügung, mit der die Verwendung der Software untersagt wurde, durch angemesseneAbänderung oder den Erwerb einer Lizenz beizulegen, so kann Altova diesen Vertrag ohnenegative Konsequenzen für Altova beenden und Ihnen anteilig alle bereits an Altova entrichtetenGebühren zurückerstatten. MIT AUSNAHME DER VORSTEHEND ANGEFÜHRTENBESTIMMUNGEN OBLIEGEN ALTOVA KEINERLEI HAFTUNGSVERPFLICHTUNGEN FÜRANSPRÜCHE IN ZUSAMMENHANG MIT URHEBERRECHTSVERLETZUNGEN. DieseHaftungsverpflichtung gilt nicht in Fällen, in denen die Urheberrechtsverletzung, ob patentrechtlichoder anderweitig, infolge einer Kombination der Altova-Software mit zusätzlich von Ihnenbereitgestellten Elementen verursacht wurde.
6. SUPPORT UND WARTUNG
Zusätzlich zu der Version des Softwareprodukts, für das Sie eine Lizenz erhalten haben, bietet
466 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
Altova eine Reihe von optionalen „Support- & Wartungspaketen“ („Software & MaintenancePackage“, „SMP“) an, die Sie zusätzlich zu Ihrer Lizenz für die Software erwerben können. Der fürdas jeweilige SMP geltende Supportzeitraum (wie nachfolgend definiert) wird beim Kauf des SMPfestgelegt. 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 sichentscheiden.
(a) Wenn Sie kein SMP erwerben, erhalten Sie beim Kauf lediglich die Software, danachjedoch keinerlei Wartungsreleases oder Updates. Obwohl die Möglichkeit besteht, dass AltovaIhnen in Einzelfällen Wartungsreleases als kostenlose Zusatzleistung zur Verfügung stellt, sind indiesen Releases keine neuen Produktfeatures, die über das beim Kauf der Software bestehendeMaß hinausgehen, beinhaltet. In jedem Fall erhalten Sie dreißig (30) Tage lang ab Kauf derSoftware (der „Supportzeitraum” im Sinne dieses Absatzes 6(a)) kostenlosen technischenSupport von Altova. Außerdem kann Altova in Einzelfällen auch während des dreißig (30) Tagedauernden Evaluierungszeitraums technischen Support als kostenlose Zusatzleistung zurVerfügung stellen. Technischen Support erhalten Sie ausschließlich über ein webbasiertesSupportformular, wobei es keine garantierte Reaktionszeit gibt.
(b) Mit dem Erwerb eines SMP haben Sie während des dafür geltenden SupportzeitraumsAnspruch auf die von Ihnen erworbene Produktversion sowie auf alle Wartungsreleases undUpdates für diese Produktversion, die während des für Sie geltenden Supportzeitraumsfreigegeben werden. Während des Supportzeitraums Ihres SMP erhalten Sie auch Upgrades aufdie entsprechende Produktversion der Software, mit der auf eine höhere Version der Software, fürdie Sie die Lizenz erworben haben, gewechselt wird und die während Ihres Supportzeitraumsfreigegeben werden. Die einzelnen Upgradeeditionen, auf die Sie innerhalb Ihres SupportzeitraumsAnspruch haben, sind in dem von Ihnen erworbenen SMP im Detail angeführt. Software, die alsgesondertes Produkt eingeführt wird, ist nicht im SMP enthalten. Wartungsreleases, Updates undUpgrades können neue Features enthalten, dies muss aber nicht der Fall sein. Darüber hinauserhalten Sie während des Supportzeitraums bevorzugten technischen Support von Altova, undzwar ausschließlich über ein webbasiertes Supportformular. Altova wird alle wirtschaftlichvertretbaren Anstrengungen unternehmen, um alle Anfragen per E-Mail innerhalb vonachtundvierzig (48) Stunden während der Geschäftszeiten (Montag bis Freitag, 8.00 bis 22.00 UhrUTC, ausgenommen Feiertage in Österreich und den USA) zu beantworten. Außerdem wirdAltova sich in angemessenem Umfang darum bemühen, Workarounds für Fehler, die bei derSoftware 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 dieVerwendung und Funktionalität der Software erheblich beeinträchtigt, wird Altova wirtschaftlichvertretbaren Anstrengungen unternehmen um Korrekturen oder provisorische Lösungenanzubieten, die in zukünftigen Updates oder Wartungsreleases enthalten sind. Diese Updatesoder 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 Fehleroder Funktionsstörungen zu verlangen oder Beispieldateien anzufordern, aus denen dasaufgetretene Softwareproblem hervorgeht. In einem solchen Fall müssen Sie die angefordertenNachweise oder Dateien, aus denen ausreichend detailliert hervorgeht, in welchen AspektenFehler bei der Software auftreten, so schnell wie möglich per E-Mail, Fax oder Expresspost mitZustellung am nächsten Tag an Altova übermitteln. Bei der Diagnose oder Analyse von Fehlernhaben Sie in zumutbarem Rahmen mit Altova zu kooperieren. Fehlerbehebungen können inWartungsreleases, Updates oder neuen Hauptversionen der Software enthalten sein. Altova istnicht verpflichtet, unwesentliche Fehler, d.h. Fehler, die die Benutzung der Software nach demErmessen von Altova nicht wesentlich beeinträchtigen, zu beheben. Sie erhalten von Altova unter
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 467Lizenzinformationen
Altova UModel 2017
keinen Umständen Beratung, Unterstützung oder Hilfestellung, die allgemeiner Natur ist und nichtin unmittelbarem Zusammenhang mit der Software steht.
Bei der Aktualisierung der Software kann es unter Umständen vorkommen, dass vor derInstallation auch Software aktualisiert werden muss, die nicht unter diesen Vertrag fällt. FürUpdates von Betriebssystem- und Anwendungssoftware, die nicht ausdrücklich Gegenstanddieses Vertrags ist, sind ausschließlich Sie verantwortlich. Solche Updates sind nicht im Umfangdieser Lizenz enthalten und werden nicht von Altova zur Verfügung gestellt. Die Erfüllung der indiesem Abschnitt 6 festgelegten Verpflichtungen durch Altova versteht sich unter der Bedingung,dass Sie die Software ordnungsgemäß verwenden und diesen Vertrag ausnahmslos jederzeiteinhalten. Altova ist nicht verpflichtet, technischen Support zu leisten, wenn nach Ansicht vonAltova 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 hervorgerufenwerden; (ii) Änderungen, Modifikationen oder Versuche, die Software abzuwandeln, die von Altovanicht schriftlich genehmigt wurden; (iii) äußere Einflüsse auf die Software, wie z.B.Naturkatastrophen, Stromausfälle, Stromschwankungen oder Computerausfälle; (iv) IhrVersä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 anderenSoftware. Sie alleine sind dafür verantwortlich: (i) allen Betriebs- und Fehlerbehebungsanleitungenvon Altova Folge zu leisten, Altova unverzüglich von Fehlern oder Defekten an der Software zuinformieren und Altova eine genaue Beschreibung dieser Fehler und/oder Defekte zu liefern; (ii) fürden Schutz Ihrer vertraulichen Informationen zu sorgen; (iii) Datensicherungssysteme und -abläufefür die Wiederherstellung verlorener oder geänderter Dateien, Daten oder Programme einzurichtenund anzuwenden.
7. AKTIVIERUNG DER SOFTWARE, UPDATES UND LIZENZÜBERWACHUNG
(a) Lizenzzählung. Die Software enthält ein integriertes Lizenzzählungsmodul zum Zweckder Überwachung der Einhaltung der Lizenzbestimmungen in kleinen LANs (Local AreaNetworks). Dieses Lizenzzählungsmodul versucht, mit anderen Rechnern in Ihrem LAN zukommunizieren. Sie gestatten Altova, Ihr internes Netzwerk zu Lizenzüberwachungszwecken zuverwenden. 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 genannteKommunikation durch Ihre Firewall-Einstellungen verhindert werden, müssen Sie eine zuverlässigeMethode implementieren, um die Verwendung der Software durch den Endbenutzer zuüberwachen und zu verhindern, dass mehr als die zulässige Anzahl an Benutzern die Softwareverwendet.
(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 Sienicht 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 vonVerletzungen des Vertrags entstandene Forderungen zu verzichten, zusätzlicheLizenzüberwachungstools zur Verfügung stellen. Falls Ihnen ein solches Tool von Altova zurVerfügung gestellt wird, sind Sie verpflichtet, es (a) zur Überwachung der Einhaltung diesesVertrags zu verwenden und (b) Altova die Verwendung Ihres internen Netzwerks zum Zweck derLizenzüberwachung und -zählung und der Generierung von Überwachungsberichten, die von Zeitzu Zeit an Altova gesendet werden, zu gestatten.
(c) Aktivierung der Software. Die Software kann Ihr internes Netzwerk und IhreInternetverbindung 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
468 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
illegale Verwendung der Software zu verhindern und den Kundenservice von Altovaweiter zu verbessern. Die Aktivierung erfolgt über einen Austausch von lizenzbezogenenDaten zwischen Ihrem Computer und dem Altova Master-Lizenzserver. Sie stimmendieser Vorgangsweise von Altova zu und verpflichten sich, allen diesbezüglichenVorgaben Folge zu leisten. Sie erklären sich damit einverstanden, dass die Verwendungvon Freischaltcodes, welche nicht von Altova erstellt werden oder wurden und nichtrechtmäßig von Altova oder einem dazu berechtigten Wiederverkäufer erworbenwurden, zum Zweck der Aktivierung oder Nutzung der Software die gewerblichenSchutzrechte von Altova sowie die Bestimmungen dieses Vertrages verletzt. Sie erklärensich weiters damit einverstanden, dass Versuche mit dem Zweck der Umgehung oderDeaktivierung der urheberrechtlichen Schutzmaßnahmen, vonLizenzmanagementsystemen oder des Altova Master-Lizenzservers die gewerblichenSchutzrechte von Altova sowie die Bestimmungen dieses Lizenzvertrages verletzen.Altova behält sich ausdrücklich das Recht vor, alle rechtlich verfügbaren sowieangemessenen Mittel zu ergreifen, um derartige Praktiken zu verhindern undentgangenen Gewinn, Schäden und Kosten zurückerstattet zu bekommen.
(d) LiveUpdate. Altova stellt Ihnen ein neues LiveUpdate Benachrichtigungsservice zurVerfügung, welches kostenlos ist. Altova kann Ihr internes Netzwerk und Ihre Internetverbindungverwenden, 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 Sieverfü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 Zustimmungzu den Bestimmungen dieses Vertrags bzw. durch Benutzung der Software erklären Sie sichdamit einverstanden, dass Altova für die in diesem Vertrag und/oder in denDatenschutzbestimmungen (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 derWebsite von Altova veröffentlichten Datenschutzbestimmungen von Zeit zu Zeit erneutdurchzulesen.
(f) Recht zur Überprüfung. Sie erklären sich damit einverstanden, dass Altova dazuberechtigt ist, die Einhaltung der Bestimmungen dieses Vertrags jederzeit nach vorherigerBenachrichtigung zu überprüfen. Falls sich bei der Überprüfung herausstellt, dass SieBestimmungen dieses Vertrags verletzen, haben Sie zusätzlich zu allen anderen aus derLizenzverletzung entstehenden Haftungsansprüchen alle angemessenen Kosten, die Altova durchdie Ü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 weltweitansässigen autorisierten Partnern zum Zweck der Datenverarbeitung, Analyse und Überprüfungnach außerhalb der EU transferiert werden können. Sie werden darauf hingewiesen, dass in denUSA ein Datenschutzmodell zur Anwendung kommt, das teils auf Gesetzen, teils aufRegierungsverordnungen und zum Teil auf Selbstregulierung beruht. Des Weiteren werden Siedarauf hingewiesen, dass der Rat der Europäischen Union befunden hat, dass diesesamerikanische Modell den in Artikel 25 der Datenrichtlinie der Europäischen Union (Richtlinie95/46/EC, 1995 O.J. (L 281) 31) festgelegten Datenschutzbestimmungen nicht "in ausreichendemAusmaß" Rechnung trägt. Laut Artikel 26 der Datenrichtlinie der Europäischen Union, dürfenpersönliche Daten dann von der Europäischen Union in ein Drittland übertragen werden, wenn die
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 469Lizenzinformationen
Altova UModel 2017
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. DurchIhre Zustimmung zu diesem Vertrag gestatten Sie die Übertragung aller derartiger Informationenan die USA sowie deren Verarbeitung gemäß diesem Vertrag und AltovasDatenschutzbestimmungen.
8. DAUER UND BEENDIGUNG
Dieser Vertrag wird folgendermaßen beendet: (a) indem Sie Altova eine schriftlicheBenachrichtigung von der Vertragsbeendigung übermitteln; (b) durch Altova in Form einerdiesbezüglichen schriftlichen Benachrichtigung, wenn Sie gegen diesen Vertrag verstoßen unddiesen 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 eineLizenzzahlung nicht entrichten oder sonstige Zahlungsverpflichtungen nicht einhalten. Der Vertrageiner 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, automatischbeendet. Bei Beendigung des Vertrags dürfen Sie die gesamte Software, die Gegenstand diesesVertrags ist, nicht mehr verwenden, müssen alle Kopien, die in Ihrem Besitz oder Einflussbereichstehen, vernichten, und müssen in zumutbarem Rahmen alle von Altova geforderten Maßnahmenergreifen, um sicherzustellen, dass keine Kopien der Software in Ihrem Besitz oderEinflussbereich verbleiben. Die in den Abschnitten 1(h), 1(i), 1(j), 1(k), 1(l), 2, 5, 7, 9, 10, 11 und11 niedergelegten Bestimmungen bleiben auch nach Beendigung dieses Vertrags weiterhinaufrecht.
9. EINGESCHRÄNKTE RECHTE UND EXPORTBESCHRÄNKUNGEN
Die Entwicklung der Software wurde ausschließlich privat finanziert. Bei der Software handelt essich um kommerzielle Computersoftware, die mit eingeschränkten Rechten ausgestattet ist.Die Verwendung, Vervielfältigung oder Weitergabe der Software durch die US-Regierung, eineBehörde oder einen Kooperationspartner der US-Regierung unterliegt den Beschränkungen imRahmen 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ürkommerzielle Computersoftware und kommerzielle Computerdokumentation an die US-Regierungals Endnutzer ausschließlich in Form einer Lizenz für kommerziell genutzte Güter erteilt, weshalbes sich bei den damit verbundenen Rechten um dieselben Rechte handelt, die allen anderenEndnutzern im Rahmen dieses Vertrags gewährt werden. Beim Hersteller handelt es sich umAltova GmbH, Rudolfsplatz, 13a/9, A-1010 Wien, Österreich/EU. Die Software und/oderDokumentation darf ausschließlich unter Einhaltung aller anwendbaren Exportbestimmungen derVereinigten Staaten von Amerika sowie des Landes, in dem Sie die Software erhalten haben,verwendet, exportiert oder wiedereingeführt werden. Insbesondere darf die Software und/oderDokumentation nicht (i) in ein Land exportiert oder wiedereingeführt werden, über das dieVereinigten Staaten ein Embargo verhängt haben, oder einem Staatsangehörigen oder Bewohnereines solchen Landes überlassen werden; oder (ii) einer Person überlassen werden, die auf derListe der Specially Designated Nationals des U.S. Treasury Department oder dem Table of DenialOrders 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 Kontrolleunterliegen, noch ein Staatsangehöriger oder Bewohner eines dieser Länder sind, noch auf einerder 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 diesenVertrag ungeachtet der vorstehenden Bestimmungen amerikanisches Recht. Falls keine
470 Lizenzinformationen Altova Endbenutzer-Lizenzvereinbarung
© 2017 Altova GmbHAltova UModel 2017
amerikanischen Bundesgesetze anwendbar sind, so gelten die Gesetze des Commonwealth ofMassachusetts. Des Weiteren unterliegen alle Ansprüche, Forderungen, Beschwerden undStreitigkeiten ungeachtet anderslautender Bestimmungen in diesem Vertrag (einschließlich abernicht beschränkt auf Absatz 5 ((Garantie)) den folgenden amerikanischen Gesetzen bzw. anderenUS-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, 2671-2672, 2674-2680), FAR 1.601(a) und 43.102 (Contract Modifications); FAR 12.302(b). Der Klarheithalber stellen wir fest: Wenn Sie ein amerikanisches bundestaatliches, staatliches oderregionales Amt, eine Institution oder Behörde oder ein öffentliches und akkreditiertesamerikanisches Bildungsinstitut sind, so können Schadenersatzansprüche an Sie nur im Rahmendes geltenden amerikanischen Rechts (z.B. Anti-Deficiency Act) geltend gemacht werden und nurin 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änzendeVermerke und/oder Nutzungsbedingungen gelten. Diese Vermerke und ergänzendenNutzungsbedingungen 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 diesesLizenzvertrags. Indem Sie Ihre Zustimmung zu den Bedingungen dieses Vertrags erteilen,
stimmen Sie auch automatisch allen ergänzenden Bestimmungen, die möglicherweise darinenthalten 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 Unionund 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 mitAltova, die in Zusammenhang mit Ihrer Verwendung der Software stehen, in die alleinigeZuständigkeit des Handelsgerichts Wien fallen. Sie erklären sich weiters ausdrücklich damiteinverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikte der persönlichenZuständigkeit des Handelsgerichts Wien unterstellt sind.
Wenn Sie sich in den Vereinigten Staaten befinden und die Software in den Vereinigten Staatenverwenden, unterliegt dieser Vertrag dem Recht des Commonwealth of Massachusetts, USA(unter Ausschluss von dessen Verweisungsnormen und der UN-Kaufrechtskonvention). Sieerklä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 dereinzel- und bundesstaatlichen Gerichte im Bundesstaat Massachusetts fallen. Sie erklären sichweiters ausdrücklich damit einverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikteder persönlichen Zuständigkeit der einzel- und bundesstaatlichen Gerichte im BundesstaatMassachusetts unterstellt sind.
Wenn Sie sich nicht in der Europäischen Union oder den Vereinigten Staaten befinden und dieSoftware nicht in den Vereinigten Staaten verwenden, unterliegt dieser Vertrag dem Recht derRepublik Österreich (unter Ausschluss von dessen Verweisungsnormen und der UN-Kaufrechtskonvention). Sie erklären sich ausdrücklich damit einverstanden, dass alleStreitigkeiten oder Konflikte mit Altova, die in Zusammenhang mit Ihrer Verwendung der Softwarestehen, in die alleinige Zuständigkeit des Handelsgerichts Wien fallen. Sie erklären sich weitersausdrücklich damit einverstanden, dass Sie bezüglich solcher Streitigkeiten oder Konflikte derpersönlichen Zuständigkeit des Handelsgerichts Wien unterstellt sind. Die Anwendung vonVerweisungsnormen einer Rechtsordnung sowie des UN-Abkommens zum internationalen
© 2017 Altova GmbH
Altova Endbenutzer-Lizenzvereinbarung 471Lizenzinformationen
Altova UModel 2017
Warenkauf (CISG) auf diesen Vertrag wird ausdrücklich ausgeschlossen.
13. ÜBERSETZUNGEN
Von Altova zur Verfügung gestellte Übersetzungen der englischsprachigen Version dienenausschließlich Ihrer Annehmlichkeit. Die englischsprachige Version des Vertrags ist die offiziellgü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 denVertragsgegenstand und tritt an die Stelle aller diesbezüglichen früheren mündlichen oderschriftlichen Vereinbarungen zwischen den Parteien. Benachrichtigungen oder sonstigeMitteilungen im Rahmen dieses Vertrags müssen schriftlich erfolgen und gelten alsordnungsgemäß übermittelt, wenn sie per Einschreiben mit Rückschein oder per Kurierdienst mitZustellung am nächsten Tag an die auf der Website von Altova angegebene Adresse (wenn Altovader 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 festgelegteund auf die vorstehend beschriebene Weise bekannt gegebene Adresse geschickt werden. DieserVertrag ist für die Vertragspartner verbindlich und geht auf ihre Erben, persönlichen undrechtlichen Vertreter, verbundenen Unternehmen, Rechtsnachfolger und zulässigenAbtretungsempfänger über. Die Nichtdurchsetzung oder Nichtausübung von Rechten oderRechtsmitteln unter diesem Vertrag durch die Vertragspartner stellt keinen Verzicht auf einsolches Recht oder Rechtsmittel dar und beeinträchtigt in keiner Weise das Recht desbetreffenden Vertragspartners, ein solches Recht oder Rechtsmittel sowie alle anderen Rechteoder Rechtsmittel aus diesem Vertrag später durchzusetzen bzw. auszuüben. Eine Änderungdieses Vertrages ist nur in Form einer schriftlich niedergelegten Vereinbarung möglich, die vonbeiden Vertragspartnern unterzeichnet wird. Wenn eine Zuwiderhandlung gegen dieBestimmungen dieses Vertrags durch einen der Vertragspartner erfolgt ist oder droht, so kann derjeweils andere Vertragspartner alle ihm zustehenden Rechte und Rechtsmittel geltend machen.Jeder Vertragspartner ist ordnungsgemäß befugt und ermächtigt, in diesen Vertrag einzutretenund die daraus erwachsenden Verpflichtungen zu erfüllen. Sollte eine Bestimmung diesesVertrags für unwirksam, rechtswidrig oder undurchführbar erklärt werden, so wird dadurch dieWirksamkeit der übrigen Bestimmungen nicht berührt, und dieser Vertrag bleibt imgrößtmöglichen rechtlich zulässigen Umfang wirksam und gültig. Die Vertragspartner haben dievorstehenden Vertragsbedingungen zur Kenntnis genommen und erklären sich ausdrücklich damiteinverstanden.
Letzte Aktualisierung: 3.9.2015
© 2017 Altova GmbH
Index 473
Index
.
.NET Framework,
UModel Projekt inkludieren, 149
11.4,
Java, 59
55.0,
Java, 59
AAbgeleitete,
Klasse, 31
Klassen einfügen, 98
Abhängigkeit,
Beziehungen anzeigen, 89, 173
inkludieren, 16
Verwendung, 43
Absolute,
und relative Links, 180
Abstrakte,
Klasse, 25
Akteur,
benutzerdefiniert, 16
Aktiviere Versionskontrolle, 355
Aktivierungsfeld,
Ausführungsspezifikation, 247
Aktivität, 210
Diagramm zu Transition hinzufügen, 210
Diagrammelemente, 199
Operation hinzufügen, 210
Verzweigung / Merge erstellen, 196
zum Zustand hinzufügen, 210
Aktivitätsdiagramm, 193
Elemente einfügen, 194
Symbole, 379
Aktualisieren,
Projektdatei, 137
Aktuellste Version holen, 356
Alle,
erweitern/reduzieren, 279
Anbieter wechseln,
Versionskontrolle, 370
Anleitung,
definierte Symbole, 126
Anmerkung,
Hyperlink von, 100
Annotation,
Dokumentation, 86
XML-Schema, 320
Anordnen,
Elemente, 93
Anpassen, 414, 419
Befehle der Symbolleiste/des Menüs, 415
Kontextmenü, 419
Menü, 419
Ansicht, 413
zu mehreren Instanzen eines Elements, 279
Antwort,
Nachricht automatisch generieren, 253
Anwendungsfall,
hinzufügen, 16
Anzeigen, 83
alle Beziehungen - Hierarchie (Register), 83
Eigenschaft als Assoziation, 89
Eigenschaft als Assziation, 164
Eigenschaftswerte, 320
grafischen Ansicht, 83
Modellbeziehungen, 89, 173
oder am Raster ausrichten, 89
Regionsnamen ausblenden, 216
Textlabels, 89, 173
Applikation,
externe - Argumente, 416
Arbeit im Team,
Unterstützung - Unterprojekte, 338
Arbeitsablauf,
Projekt, 118
Arbeitsverzeichnis,
Index
© 2017 Altova GmbH
474
Arbeitsverzeichnis,
Versionskontrolle, 353
Argumente,
externe Tools, 416
Artefakt,
Manifestation, 48
zu Node hinzufügen, 48
Assoziation,
aggregrieren/zusammensetzen, 25
automatische Anzeige, 170
beim Code Engineering anzeigen, 59
Beziehungen anzeigen, 89, 173
Eigenschaft als Ass. anzeigen, 89
Klasse memberEnd, 170
mit Drag-and-Drop erstellen, 175
Objektverknüpfungen, 37
Qualifier, 170
Rolle, 170
Tpy definieren, 170
typisierte Eigenschaft anzeigen, 164
Use Case, 16
Zeilendicke, 89
zwischen Klassen, 25
Attribut,
Autokomplettierungsfenster, 421
Eigenschaftswerte ein-/ausblenden, 306
ein-/ausblenden, 279
in Modelll-Strukur auswählen, 78
Stereotyp, 306
Attribut auswählen,
in Modell-Struktur, 78
Attribute,
coloring, 285
Auflisten,
nicht verwendete Elemente, 69
Aufruf,
Nachricht, 253
Aufrufoperation,
einfügen, 194
Aufrufverhalten,
einfügen, 194
Ausblenden,
Eigenschaftswerte - Attribute, 306
einblenden - Slot, 279
Textlabels, 89, 173
Auschecken, 359
Auschecken rückgängig, 361
Ausführungsspezifikation,
Lebenslinie, 247
Ausgabe,
XMI-Datei, 334
Ausgliedern,
aus Versionskontrolle, 364
Auslösendes Ereignis,
Zeitverlaufsdiagramm, 275
Ausnahme,
Ausnahmeereignis hinzufügen, 279
Ausnahmeereignis,
hinzufügen, 279
Java-Operation, 126
Ausrichten,
am Raster - Raster anzeigen, 89
beim Ziehen an Hilfslinien ausrichten, 421
Elemente, 93
Elemente beim Ziehen, 16
Ausrichtungshilfslinien, 16
Außer Kraft setzen,
SPL-Standardvorlagen, 137
Austrittspunkt,
zu Unterautomat hinzufügen, 216
Autokomplettierung, 93
Einzelmodus / Mehrfachmodus, 93
Fenster - Typen, 93
Fenster zum Bearbeiten von Klassen, 421
Funktion, 25
Autokomplettierung auf Wunsch,
Strg+Leertaste, 93
Automatisch,
Assoziationen anzeigen, 170
Automatisch generieren,
Antwortnachricht, 253
Automatischer,
Hyperlink, 100
BBall and socket,
Interface notation, 279
Bank,
Beispieldateien, 106
Basis,
Klasse, 31
Basisklasse,
abgeleitete einfügen, 98
© 2017 Altova GmbH
Index 475
Basisklasse,
überschreiben, 279
Batch, 114
Batchverarbeitung, 114
new / load / save, 114
Verarbeitung, 110
vollständiger Batch-Modus, 114
Bearbeiten, 402
Bearbeitungen rückgängig machen, 361
Befehl, 114, 419
aus Menü löschen, 419
Kontextmenü, 419
Menü zurücksetzen, 419
Zeile - new / load / save, 114
Zeilenverarbeitung, 114
Befehle,
zur Symbolleiste/zum Menü hinzufügen, 415
Befehlszeile,
Verarbeitung, 110
Beispiele,
Beispieldateien, 106
Ordner Tutorial, 10
Benutzer,
examples Ordner für mehrere Benutzer, 10
Benutzerdefinierte,
SPL-Vorlagen, 137
Stereotypstile, 312
Benutzerdefinierter,
Akteur, 16
Benutzerdefiniertes,
Stereotypsymbol, 314
Benutzeroberfläche, 68
Bereich,
einzelne/mehrere erweitern, 279
Bezeichnung,
IDs und UUIDs, 334
Beziehung,
alle anzeigen - Hierarchie (Register), 83
Modellbeziehungen anzeigen, 89, 173
Beziehungen,
Element, 170
Verwendung von Ziehpunkten, 175
Binärdateien, 131
C# und Java importieren, 131
Unterstützung von "obfuscated" Binärdateien, 131
Bitmap,
Elemente speichern, 402
Borland,
bsdj-Projektdatei, 405
Breite,
Linienbreite, 89
bsdj,
Borland-Projekt, 405
CC#,
Binärdatei importieren, 131
Code, 436
Code in Modell - Entsprechungen, 146
Importeinstellungen, 126
C++,
Code, 436
Call-Nachricht,
gehe zu Operation, 253
Cascading,
Styles, 80
Class,
syntax coloring, 285
Classifier,
einschränken, 162
neu, 139
umbenennen, 139
Code, 52, 141
Code zu Sequenzdiagramm hinzufügen, 267
generieren - Mindestvoraussetzungen, 143
Java-Code und Klassendateinamen, 141
mehrere Sequenzdiagramm anhand von Code generieren, 262
Refactoring, 141
Round Trip Engineering, 52
Sequenzdiagramm generieren, 259
SPL, 437
Standard, 421
Synchronisierung, 137
von Sequenzdiagramm generieren, 264
Voraussetzungen, 52
Zielverzeichnis, 52
Code - C#,
in UModel Elemente, 146
Code - VB.NET,
to UModel elements, 148
Code - XML-Schema,
auf UModel Elemente, 147
Code Engineering, 52, 59
Index
© 2017 Altova GmbH
476
Code Engineering, 52, 59
Assoziationen anzeigen, 59
Importverzeichnis, 59
Komponentenrealisierungen generieren, 139
Mini-Projekt, 121
Projektdatei in neuen Ordner verschieben, 118
Code Generator, 436
Codegenerierung,
Namespace als Verzeichnis verwenden, 52
Color,
syntax coloring - enable/disable, 285
Combined Fragment, 248
Constraint, 69
in Diagramm hinzufügen, 69
mehreren Elementen zuweisen, 69
Content Model,
des XML-Schemas, 326
Copyright-Informationen, 452
CR/LF,
für ump-Datei beim Speichern, 118
csproj - csdproj,
MS Visual Studio .Net, 405
DDatei, 397
new / load / save - Batch, 114
Projektdateien zusammenführen, 151
Tutorial-Beispiel, 10
ump, 118
von URL öffnen, 397
Datei abrufen,
Versionskontrolle, 357
Datei holen,
Versionskontrolle, 356
Dateien,
Beispieldateien, 106
Datentype,
in Schema definieren, 326
Datentypen,
hinzufügen - Autokomplettierung, 93
Deaktiviere Versionskontrolle, 355
Definierte,
Symbole - Code importieren, 126
Deployment,
Diagramm, 48
Symbole, 384
Deployment-Diagramm, 297
Diagram,
- Use Case-Diagramm, 234
Diagramm, 262, 279, 298
- Aktivitätsdiagramm, 193
- Interaktionsübersichtsdiagramm, 239
- Klassendiagramm, 279
- Profil, 304
Aktivität zu Transition hinzufügen, 210
alle bis auf das aktive schließen, 89
als png speichern, 397
Code von Sequenzdiagramm generieren, 264
Code zu Sequenzdiagramm hinzufügen, 267
Deployment-Diagramm, 297
Diagrammüberschrift anzeigen, 93
Eigenschaften, 89
Elemente als Bitmap speichern, 402
Elemente aus inkludierten Dateien igrnoieren, 421
Elemente durch Constraint einschränken, 69
Größe anpassen, 89
Hyperlink, 100
Kommunikationsdiagramm, 235
Komponentendiagramm, 296
Kompositionsstrukturdiagramm, 294
Linienbreite, 89
mehrere Klasseninstanzen, 279
mehrere Sequenzdiagramm anhand eines Diagrammsgenerieren, 262
nur in Diagramm einfügen, 95
Objektdiagramm, 297
offene Diagramme mit Projekt speichern, 421
öffnen, 74
Paket und Diagramm freigeben, 158
Paketabhängigkeiten erstellen, 298
Paktediagramm, 298
Quellcodekommentare anzeigen, 89
Sequenzdiagramm, 244
Sequenzdiagramm anhand von Getter / Setter generieren, 262
Sequenzdiagramm generieren, 259
Stile, 80
Symbole, 378
XML-Schema, 318
XML-Schema - Import, 320
Zeitverlaufsdiagramm, 270
Zusätzliches - XML-Schema, 318
Zustandsdiagramm, 208
Diagramme, 192
© 2017 Altova GmbH
Index 477
Diagramme, 192
Strukturdiagramme, 279
Verhaltensdiagramme, 193
Diagrammfenster, 89
Diagramm-Struktur, 74
Dokument,
Hyperlink zu, 100
Dokumentation, 180
Annotation, 86
relative Links, 180
UML-Projekt generieren, 180
Dokumentation (Register), 86
Download Versionskontroll-Projekt, 353
Drag and Drop,
rechte Maustaste, 98
Drag-and-Drop,
Assoziation mit Ziehpunkten erstellen, 175
Druckaufbereitung,
XMI-Ausgabe, 334
Drucken,
Druckvorschau, 397
Duchsuchen von Registern, 68
Durch Constraint einschränken,
Element, 69
EEigenschaft,
als Assoziation anzeigen, 89, 173
als Lebenslinie typisiert, 247
typisierte - anzeigen, 164
wiederverwenden, 31
Eigenschaften, 78
hinzufügen, 25
Versionskontrolle, 369
Eigenschaftswert,
Standardwert, 310
Eigenschaftswerte,
anzeigen, 320
Attribute ein-/ausblenden, 306
Definitionen, 304
Ein-/ausblenden,
Attribute, Operationen, 279
Ein-/Ausschalten,
Kompaktmodus, 320
Einblenden,
ausblenden - Eigenschaftswerte / Attribute, 306
ausblenden - Slot, 279
Einchecken, 360
Einfügen, 194
Aktion (Aufrufoperation), 194
Aktion (Aufrufverhalten), 194
einfachen Zustand, 210
Element in Diagramm, 95
Elemente, 98
Interaktionsübersichtselemente, 240
Kompositionsstrukturelemente, 295
mit..., 98
nur in Diagramm, 95
Paketdiagrammelemente, 299
Zeitverlaufsdiagrammelemente, 271
Einführung, 6
Einschränken,
Classifier, 162
Elemente durch Constraint einschränken, 69
Einschränkung,
Syntaxüberprüfung, 405
Einstelllungen,
Synchronisierung, 137
Einstellungen,
Versionskontrolle, 421
Eintrittspunkt,
zu Unterautomat hinzufügen, 216
Einzelmodus,
Autokomplettierung, 93
Element, 69
Assoziationen beim Importieren, 59
ausgewählte als Bitmap speichern, 402
ausrichten, 93
ausschneiden, kopieren, einfügen, 95
Beziehungen, 170
Constraint zuweisen, 69
Dokumentation generieren, 180
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, 421
Zustandsdiagramm einfügen, 209
Endbenutzer-Lizenzvereinbarung, 452, 457
Index
© 2017 Altova GmbH
478
Entfernen,
aus Favoriten, 76
Enumeration,
Standardwert, 310
und Stereotype, 310
Erstellen,
getter / setter Methoden, 279
XML-Schema, 330
Erweitern,
alle Klassenbereiche, 279
Pakete reduzieren, 69
Erweiterung,
XMI, 334
Evaluierungszeitraum,
bei Altova Software-Produkten, 456
für Altova-Software-Produkte, 453
von Altova Software-Produkten, 452
Export,
als XMI, 334
Extras, 414
Optionen, 421
Zum Menü 'Extras' hinzufügen, 416
FFarbe,
transparenter Hintergrund, 314
Favoriten, 76
Fehlende Elemente,
auflisten, 69
Fehler,
Meldungen, 88
Syntaxüberprüfung, 52
Fenster, 428
Standardeinstellungen wiederherstellen, 414
Fensterbereich "Meldungen", 88
Filtertypen,
Autokomplettierungsfenster, 93
Format,
Autokomplettierungsfenster, 93
benutzerdefiniertes Stereotypformat, 312
Forward,
Engineering, 143
Freigeben,
aus Versionskontrolle, 365
Paket und Diagramm, 158
GGate,
Sequenzdiagramm, 252
Gehe zu,
Lebenslinie, 247
Generalisieren,
spezialisieren, 31
Generics,
Unterstützung für Java und C#, 162
Generieren,
Antwortnachricht automatisch generieren, 253
Code von Schema, 436
Komponentenrealisierungen automatisch generieren, 139
mehrere Sequenzdiagramm anhand von Code generieren, 262
Sequenzdiagramm anhand von Code, 259
Sequenzdiagramm von Kommunikationsdiagramm, 236
UML-Projektdokumentation, 180
XML-Schema, 330
Geschwindigkeit,
Verbesserung, 167
Get,
getter / setter Methoden, 279
Getter / Setter,
Sequenzdiagramm anhand von Getter / Setter generieren, 262
Grafische Ansicht,
einzige Gruppe von Beziehungen, 83
Größe,
Diagrammfenster, 89
HHierarchie,
alle Beziehungen anzeigen, 83
Hierarchiediagramm,
In Dokumentation angezeigte Ebenen, 180
Hilfe, 429
Hilfslinie,
beim Ziehen mit der Maus, 421
Hintergrund,
transparente Farbe, 314
Hinzufügen, 16, 362
Diagramm zu Paket, 16
© 2017 Altova GmbH
Index 479
Hinzufügen, 16, 362
Einfügen - Löschen aus der Modell-Struktur, 69
Modell-Link, 100
neues Projekt, 118
Paket zu Projekt, 16
Projekt in Versionskontrolle, 362
verschieben - löschen - Diagramm, 89
Versionskontrolle, 362
zu Favoriten, 76
Höhe angleichen,
Höhe - Breite - Größe, 93
Hyperlink, 100
automatischer, 100
IID,
IDs und UUIDs, 334
Ignorieren,
Elemente in Liste, 421
Operationsnamen, 259
Verzeichnisse, 421
Import, 59
Assoziationselemente, 59
C#-Projekt, 126
Quellprojekt, 59
Verzeichnis, 59
XMI-Datei, 334
XML-Schema, 320
Importieren, 126
Binärdateien, 131
Projekt, 126
Quellcode, 126
relativ zur UMP-Datei, 126
von UModel generierte XMI-Datei, 334
Inkludieren, 158
.NET Framework, 149
Abhängigkeit, 16
Paket und Diagramm freigeben, 158
Status - ändern, 158
UModel Projekt, 149
Unterprojekt wieder in Hauptprojekt inkludieren, 340
Installation,
Ordner examples, 10
Installer,
mehrere Benutzer, 10
Instanz, 37
Diagramm, 37
mehrere Klassen, Anzeige, 279
Objekt, 37
Integrieren,
Unterprojekte in Hauptprojekt inkludieren, 340
Intelligentes,
Autokomplettieren, 25
Interaction Use, 252
Interaktinosoperand, 248
Interaktionsoperand,
mehrzeiliger, 248
Interaktionsoperator,
definieren, 248
Interaktionsübersicht,
Elemente einfügen, 240
Interaktionsübersichtsdiagramm, 239
Symbole, 385
Interface,
ball and socket, 279
JJava,
Ausnahmeereignis, 126
Binärdatei importieren, 131
Code, 436
Code und Klassendateinamen, 141
Namespace Root, 143
unterstützte Versionen, 59
JavaDocs, 86
KKatalog,
Datei - XMLSpy Katalogdatei, 421
Klasse, 121, 279
abgeleitete, 31
abgeleitete Klassen einfügen, 98
abstrakte und konkrete, 25
Assoziationen, 25
Autokomplettierungsfenster aktivieren, 421
ball and socket interface, 279
Basis, 31
Index
© 2017 Altova GmbH
480
Klasse, 121, 279
Basisklasse überschreiben, 279
Eigenschaften hinzufügen, 25
erweitern, Bereiche reduzieren, 279
in Komponentendiagramm, 43
in Namespace erstellen, 121
in Namespace generieren, 121
mehrere Instanzen in einem Diagramm, 279
Namensänderungen - Synchronisierung, 141
Operation - überschreiben, 279
Operationen hinzufügen, 25
Symbole, 380
Synchronisierung, 137
Klassendiagramm, 279
neues hinzufügen, 25
Klassennamen ändern,
Auswirkung auf Codedateinamen, 141
Knoten,
Stile, 80
Kollaboration,
Kompositionsstrukturdiagramm, 295
Kommentare,
Dokumentation, 86
Quellcodekommentare im Diagramm anzeigen, 89
Kommunikationsdiagramm, 235
Symbole, 381
von Sequenzdiagramm generieren, 236
Kompakt,
Modus - ein-/ausschalten, 320
Kompatibilität,
Projekte aktualisieren, 137
Komponente, 43
Diagramm, 43
Klasse einfügen, 43
Realisierung, 43
Symbole, 383
Komponentendiagramm, 296
Komponentenrealisierung,
automatische Generierung, 139
Komposition,
Assoziation - erstellen, 25
Kompositionsstruktur,
Elemente einfügen, 295
Kompositionsstrukturdiagramm, 294
Symbole, 382
Konkrete,
Klasse, 25
Kontextmenü,
Befehle, 419
Kopieren,
einfügen in Diagramm, Modell-Struktur, 95
LLabel,
Textlaben ein-/ausblenden, 89, 173
Layout, 412
Lebenslinie,
allgemeiner Wert, 271
Attribute, 247
Eigenschaft vom Typ Lebenslinie, 247
Gehe zu, 247
Linie,
orthogonal, 43
Linien,
formatieren, 37
Hilfslinien, 421
Stärke/Dicke in Diagrammen, 89
Link, 100
Hyperlink erstellen, 100
Model-Strukturelement, 100
Links,
relativ zur Dokumentation, 180
Lizenz, 457
Informationen, 452
Lizenzüberwachung,
bei Altova-Produkten, 454
Lokale Dateien,
absolute oder relative Links, 180
Lokales Projekt, 353
Löschen,
aus Favoriten, 76
Befehl aus der Symbolleiste löschen, 415
Befehl aus Kontextmenü, 419
Klassenbeziehung, 170
Symbol aus der Symbolleiste, 415
Symbolleiste, 415
Tastaturkürzel, 419
MMail,
© 2017 Altova GmbH
Index 481
Mail,
Projekt senden, 397
Manifest,
Artekfakt, 48
Mappen,
C# in/von Modellelementen, 146
Mapping,
VB.NET to/from model elements, 148
XML-Schema von/auf Modellelemente, 147
Maus,
kopieren, einfügen, 95
Mehrere Benutzer,
Ordner examples, 10
Mehrere Elemente,
Stilanzeige, 80
Mehrfachmodus,
Autokomplettierung, 93
Mehrzeilig,
Use Case, 16
Mehrzeiliger,
Akteurtext, 16
Interaktionsoperand, 248
Meine Dokumente,
Beispieldateien, 10
Member End,
Stereotyp, 306
MemberEnd,
Assoziation, 170
Menü, 419
Anpassen, 419
Ansicht, 413
bearbeiten, 402
Befehl hinzufügen/löschen, 415
Befehle daraus löschen, 419
Datei, 397
Extras, 414
Fenster, 428
Hilfe, 429
Layout, 412
Menü hinzufügen, 416
Projekt, 405
Standardmenü/XMLSPY, 419
Merge,
in Aktivität erstellen, 196
Mergen,
Code aus dem Modell, 52
Metadaten,
XMI-Ausgabe, 334
Methode, 262
Ausnahmeereignis hinzufügen, 279
mehrere Sequenzdiagramm generieren, 262
Sequenzdiagramm anhand von Getter / Setter generieren, 262
Sequenzdiagramm generieren, 259
Methoden,
getter / setter, 279
Mindestvoraussetzungen,
Bedingungen für die Codegenerierung, 143
Miniprojekt,
Code Engineering, 121
Modell,
Klassennamen ändern - Auswirkung in Java, 141
Link, hinzufügen, 100
Modell von Code,
Assoziationen anzeigen, 59
Modellieren,
Performance verbessern, 167
Modell-Struktur, 69
Attribut auswählen, 78
Fensterbereich, 69
Hyperlink zu Element erstellen, 100
Pakete öffnen, 69
MS Visual Studio .Net,
csproj - csdproj-Projektdatei, 405
NNachricht, 253
Aufruf, 253
einfügen, 253
gehe zu Operation, 253
nummerieren, 253
Objekt erstellen, 253
Pfeile, 253
verschieben, 253
Zeitverlaufsdiagramm, 277
Nachrichtenpfeile verschieben, 253
Name,
Regionsnamen - ein- /ausblenden, 216
Namespace,
erstellen - Code Engineering, 121
Java Namespace Root, 143
Verwendung für Codegenerierung, 52
Native Oberfläche ausführen, 370
Navigieren,
Index
© 2017 Altova GmbH
482
Navigieren,
Hyperlink, 100
Neu,
Classifier, 139
Neue Zeile,
in Lebenslinie, 236
Interaktionsoperand, 248
Nicht verwendete Elemente,
auflisten, 69
Node,
Artefakt hinzufügen, 48
hinzufügen, 48
Nummerieren,
Nachrichten, 253
OObjekt, 37
Diagramm, 37
Nachricht erstellen, 253
Symbole, 386
Verknüpfungen - Assoziationen, 37
Objektdiagramm, 297
Öffnen,
Diagramm, 74
Pakete in der Baumstrukturansicht, 69
Projekt-Versionskontrolle, 353
URL, 397
Operand,
Interaktion, 248
Operation, 279
Ausnahmeereignis, 126
Autokomplettierungsfenster, 421
automatisch zu Aktivität hinzufügen, 210
beim Generieren von Sequenzdiagrammen ignorieren, 259
coloring, 285
ein-/ausblenden, 279
gehe zu von Call-Nachricht, 253
überschreiben, 279
Vorlage, 164
wiederverwenden, 31
Operation automatisch hinzufügen, 210
Operationen,
hinzufügen, 25
Operator,
Interaktion, 248
Optionen,
Extras, 421
Projekt, 166
Versionskontrolle, 421
Ordner,
in Versionskontrolle abrufen, 358
Ordner examples, 10
Ordner abrufen,
Versionskontrolle, 358
Orthogonale,
Linie, 43
Orthogonaler,
Zustand, 216
OwnedEnd,
Assoziation, 170
Ownership,
Punkt, 175
PPaket,
als Namespace-Paket erstellen, 121
erweitern/reduzieren, 69
freigeben, 158
Profil, 306
Paketdiagramm, 298
Abhängigkeiten erstellen, 298
Elemente einfügen, 299
Symbole, 387
Paketmerge, 299
Pakteimport, 299
Parameter,
Batch, 110
Vorlage, 164
Performance,
Verbesserung, 167
Pfad,
Import relativ zur UMP-Datei, 126
Namespace in Code verwenden, 52
Ordner examples, 10
Projekt verschieben, 118
Projektordner ändern, 118
SPL-Vorlagenpfad, 438
PNG,
Diagramm speichern, 397
Pretty Print,
© 2017 Altova GmbH
Index 483
Pretty Print,
Projekt mit Pretty Print speichern, 118
Profil, 304
- Diagramm, 304
Diagramm, 304
Stereotype, 306
Zuweisung, 304
Projekt, 405
2-Weg-Zusammenführung, 151
3-Weg-Zusammenführung, 152, 154
Arbeitsablauf, 118
Datei - aktualisieren, 137
Dokumentation generieren, 180
entfernen aus Versionskontrolle, 364
erstellen, 118
Hinzufügen in Versionskontrolle, 362
importieren, 126
letzten beim Starten öffnen, 421
Namespace-Paket erstellen, 121
offene Diagramme speichern, 421
Optionen, 166
Paket einfügen, 118
per E-Mail senden, 397
speichern - Pretty Print, 118
Standardcode, 421
Stile, 80
Syntaxüberprüfung, 405
UModel Projekt inkludieren, 149
Unterprojekte erstellen, 340
verschieben, 118
zusammenführen, 151
Projekt öffnen,
Versionskontrolle, 353
Projektdateien,
Borland - MS Visual Studio .Net, 405
Projektzusammenführung,
2-Weg, 151
3-Weg, 152, 154
Property,
coloring, 285
Provider,
auswählen, 353
Punkt,
Ownership, 175
QQualifier,
Assoziation, 170
Quellcode,
importieren, 126
Quelle,
Codekommentare - im Diagramm anzeigen, 89
RRahmen,
UML-Diagrammüberschrift anzeigen, 93
Raster,
Elemente an Hilfslinien ausrichten, 16
Hilfslinien, 421
Raster anzeigen, 89
Realisierung,
Komponente, 43
Komponentenrealisierungen generieren, 139
Rechtliches, 452
Rechts ziehen, 98
Reduzieren,
Klassenbereiche, 279
Refactoring,
Klassennamen - Synchronisierung, 141
Referenz, 396
referenzierte Klasse anzeigen, 89
Region,
zu zusammengesetztem Zustand hinzufügen, 216
Regionsname,
ein- / ausblenden, 216
Relativ,
Dateien importieren/speichern, 126
Relative,
Links, 180
Rolle,
Assoziation, 170
Root,
Java Namespace, 143
Katalog - XMLSpy, 421
Paket/Klasse synchronisieren, 137
Round Trip, 52
Index
© 2017 Altova GmbH
484
Round Trip, 52
Code - Modell -Code, 59
Engineering, 52
Modell - Code - Modell, 52
SSC,
syntax coloring, 285
Schaltflächen,
Sichtbarkeitsschaltflächen, 279
Schema,
Code Generator, 436
Datentype - definieren, 326
XML-Schema, 318
XML-Schema - Import, 320
XML-Schema erstellen, 330
Schließen,
alle Diagramme bis auf das aktive, 89
Schnittstelle,
implementieren, 279
Seite,
Umbruch verhindern, 397
Senden per E-Mail,
Projekt, 397
Sequenz,
Symbole, 390
Sequenzdiagramm, 244
Code generieren, 264
Code hinzufügen, 267
Combined Fragment, 248
Elemente einfügen, 245
Gate, 252
Interaction Use, 252
Lebenslinie, 247
Nachrichten, 253
von Kommunikationsdiagarmm generieren, 236
zu ignorierende Operationsnamen, 259
Zustandsinvariante, 253
Set,
getter / setter Methoden, 279
Setter / Getter,
Sequenzdiagramm generieren, 262
Shortcut, 419
Show,
tagged values, 324
Sichtbarkeit,
Schaltflächen - auswählen, 279
Signatur,
Vorlage, 162, 163
Slot,
ein-/ausblenden, 279
Software-Produktlizenz, 457
Sortieren,
Diagramm, 74
Elemente in der Modell-Struktur, 69
Speichern,
Diagramm als Bild speichern, 397
Elemente als Bitmap, 402
Unterprojektdateien, 340
Spezialisieren,
generalisieren, 31
SPL, 437
benutzerdefinierte, 137
Codeblöcke, 437
foreach, 446
SPL-Vorlagen,
Vorlagenpfad, 438
Standard,
Pfad - Ordner examples, 10
Projektcode, 421
SPL-Vorlagen, 137
Standardmenü,
Menü, 419
Standardwert,
Eigenschaftswert, 306
Start,
UModel, 12
Starten,
mit letzten Projekt, 421
Status aktualisieren,
Versionskontrolle, 370
Stereotyp,
Attribute - definieren, 306
benutzerdefinierte Stile, 312
benutzerdefiniertes Symbol, 314
Member End, 306
Profile, 306
Standardeigenschaftswert, 310
und Enumeration, 310
zuweisen, 306
Stereotype,
Definition, 304
Stil,
© 2017 Altova GmbH
Index 485
Stil,
benutzerdefinierte Stereotypstile, 312
Stile,
cascading Styles, Vorrang, 80
mehrere Auswahlen, 80
Stile (Register), 80
Strg+Leertaste,
Autokomplettierung auf Wunsch, 93
Strukturdiagramme,
Diagramme, 279
Suchen, 69
Modellierungselemente, 69, 402
nicht verwendete Elemente, 69
Register durchsuchen, 68
Symbol, 384
Aktivitätsdiagramm, 379
benutzerdefiniertes Stereotypsymbol, 314
Deployment, 384
groß anzeigen, 420
Klasse, 380
Komponente, 383
Objekt, 386
Sequenz, 390
Verteilung, 384
zur Symbolleiste/zum Menü hinzufügen, 415
Symbole,
definierte - Code importieren, 126
Interaktionsübersichtsdiagramm, 385
Kommunikationsdiagramm, 381
Kompositionsstrukturdiagramm, 382
Paketdiagramm, 387
Use Case, 393
XML-Schemadiagramm, 394
Zeitverlaufsdiagramm, 392
Zustandsdiagramm, 391
Symbolleiste,
aktivieren/deaktivieren, 415
Befehl hinzufügen, 415
große Symbole anzeigen, 420
neue erstellen, 415
Standardeinstellungen wiederherstellen, 414
Symbolleiste & Menübefehle zurücksetzen, 415
Synchronisieren,
Code aus dem Modell übernehmen, 52
mit neuem Ordner, 118
Modell von Code mergen, 59
Root/Paket/Klasse, 137
Synchronisierung, 141
Änderung von Klassennamen, 141
Einstellungen, 137
Klasse und Codedateinamen, 141
Syntax, 52
Batch-Datei, 110
Fehler - Warnungen, 52
Projektsyntax überprüfen, 405
überprüfen, 52
Überprüfung - Meldungen, 88
Syntax coloring, 285
TTagged values,
show, 324
Tastaturkürzel,
in Tooltipp anzeigen, 420
zuweisen/löschen, 419
Teamwork,
Unterstützung - Unterprojekte, 338
Teilweise Dokumentation,
generieren, 180
Textlabels,
ein-/ausblenden, 89, 173
Tick-Symbol,
Zeitverlaufsdiagramm, 274
Tooltipp, 420
anzeigen, 420
Tastaturkürzel anzeigen, 420
Transition, 210
Aktivitätsdiagramm hinzufügen, 210
Trigger definieren, 210
zwischen Zuständen definieren, 210
transparent,
Hintergrundfarbe, 314
Trigger,
Transitions-Trigger definieren, 210
Tutorial, 10
Beispieldateien, 10
Ordner examples, 10
Ziele, 10
Typ,
Eigenschaft - anzeigen, 164
Typen,
und Autokomplettierung, 93
Typisieren,
Index
© 2017 Altova GmbH
486
Typisieren,
Eigenschaft - als Lebenslinie, 247
UÜberführen,
Code in Modell, 405
Modell in Code, 405
Überprüfen,
Projektsyntax, 405
Überschreiben,
Code aus Modell, 405
Klassenoperationen, 279
Modell aus Code, 405
Überschrift,
UML-Diagrammüberschrift anzeigen, 93
Übersicht (Fensterbereich), 86
Umbenennen,
Classifier, 139
Umbruch,
Umbruch verhindern, 397
UML,
Diagramm - freigeben, 158
Diagramme, 192
Diagrammüberschrift - anzeigen, 93
Sichtbarkeitsschaltflächen, 279
Variablen, 438
Vorlagen, 162
UModel,
auf XML-Schema-Code, 147
generierte XMI-Datei importieren, 334
in C# Code, 146
starten, 12
to VB.NET code, 148
UModel Diagrammsymbole, 378
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, 216
Unterklasse,
in Diagramm einfügen, 98
Unterprojekt, 340
erstellen, 340
öffnen / bearbeiten, 340
und Versionskontrolle, 338
Unterprojektdateien speichern, 340
Unterprojekte,
Unterstützung für die Arbeit im Team, 338
Unterschiede anzeigen, 368
URL,
Datei über URL öffnen, 397
Use Case, 16
Assoziation, 16
Bereiche, 16
hinzufügen, 16
mehrzeilig, 16
Symbole, 393
Use Case diagram, 234
UUID,
Universal Unique Identifiers, 334
Vvalue,
tagged, show, 324
Variablen,
externe Tool-Argumente, 416
UML, 438
VB.NET,
code to model correspondence, 148
Verbessern,
Performance, 167
Verhaltensdiagramme, 193
Verlauf,
anzeigen, 366
Verlauf anzeigen, 366
Verschieben,
Projekt, 118
Versionsdateien vergleichen, 368
Versionskontrolle,
aktivieren /deaktivieren, 355
aktuellste Version holen, 356
auschecken, 359
Auschecken rückgängig, 361
ausgliedern, 364
Befehle, 353
Datei abrufen, 357
Eigenschaften, 369
© 2017 Altova GmbH
Index 487
Versionskontrolle,
Einchecken, 360
Hinzufügen in Versionskontrolle, 362
installieren eines Versionskontroll-Plug-in, 348
native Oberfläche ausführen, 370
Optionen / Einstellungen, 421
Projekt öffnen, 353
Status aktualisieren, 370
Unterprojekte - Arbeit im Team, 338
Unterschiede anzeigen, 368
Verlauf anzeigen, 366
Versionskontrollsystem wechseln, 370
Verteilung,
Symbole, 384
Vertrieb,
von Altova Produken, 456
von Altova Software-Produkten, 452
von Altova-Software-Produkten, 453
Verwendung,
Abhängigkeit, 43
Vorlage, 164
Verzeichnis, 52
beim Zusammenführen igrnoieren, 421
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, 196
Vollständiger Batch-Modus, 114
Voraussetzungen,
Forward Engineering, 143
Vorlage,
Signatur, 162, 163
Verwendung, 164
Vorlagen,
benutzerdefinierte SPL, 137
Operation/Parameter, 164
SPL-Vorlagen, 438
WWaagrecht anordnen, 93
Warnung,
Meldungen, 88
Syntaxküberprüfung, 52
Web,
Hyperlink, 100
Wert,
Eigenschaftsswert, 306
Werte,
Eigenschaftswerte, 304
Eigenschaftswerte anzeigen, 320
Wertverlaufslinie,
Zeitverlaufsdiagramm, 271
Wiederherstellen,
Symbolleisten und Fenster, 414
Wiederverwendung,
von Unterprojekten, 340
XXMI, 334
Druckaufbereitung für die Ausgabe, 334
Erweiterungen, 334
XML-Schema, 326
Annotation, 320
Diagramm, 318
Entsprechung Code - Modell, 147
erstellen/generieren, 330
XML-Schema - Element einfügen,
Content Model, 326
XML-Schemadiagramm,
Symbole, 394
ZZeilenumbruch,
im Akteurtext, 16
Zeitbedingung,
Zeitverlaufsdiagramm, 276
Zeitdauerbedingung,
Zeitverlaufsdiagramm, 275
Zeitlinie,
Zustandsänderungen definieren, 271
Zeitverlaufsdiagramm, 270, 271
auslösendes Ereignis, 275
Elemente einfügen, 271
Index
© 2017 Altova GmbH
488
Zeitverlaufsdiagramm, 270, 271
Lebenslinie, 271
Nachricht, 277
Symbole, 392
Tick-Symbol, 274
wechseln zwischen Typen, 271
Wertverlaufslinie, 271
Zeitbedingung, 276
Zeitdauerbedingung, 275
Zeitlinie, 271
Zentrieren,
Elemente, 93
Ziehpunkt,
Beziehung erstellen, 175
Zoomen,
Größe anpassen, 89
Zurücksetzen,
Menübefehle, 419
Symbolleiste & Menübefehle, 415
Tastaturkürzel, 419
Zusammenführen,
Projekte, 151
Verzeichnis ignorieren, 421
Zusammenführung,
2-Weg-Projektzusammenführung, 151
3-Weg-Projektzusammenführung, 152, 154
Zusammengesetzter Zustand,
Region hinzufügen, 216
Zustand, 210
Aktivität hinzufügen, 210
einfachen einfügen, 210
orthogonaler, 216
Transition definieren, 210
Unterautomatenzustand, 216
zusammengesetzter, 216
Zustandsänderungen,
auf einer Zeitlinie definieren, 271
Zustandsdiagramm,
Diagrammelemente, 228
Elemente einfügen, 209
Symbole, 391
zusammengesetzte Zustände - Regionen, 216
Zustände, Aktivitäten, Transitionen, 210
Zustandsdiragramm, 208
Zustandsinvariante, 253
Zuweisen,
Stereotyp, 306
Tastaturkürzel zu einem Befehl, 419