All rights reserved. No parts of this work may be reproduced in any form or by any means- graphic, electronic, or mechanical, including photocopying, recording, taping, orinformation storage and retrieval systems - without the written permission of the publisher.
Products that are referred to in this document may be either trademarks and/or registeredtrademarks of the respective owners. The publisher and the author make no claim tothese trademarks.
While every precaution has been taken in the preparation of this document, the publisherand the author assume no responsibility for errors or omissions, or for damages resultingfrom the use of information contained in this document or from the use of programs andsource code that may accompany it. In no event shall the publisher and the author beliable for any loss of profit or any other commercial damage caused or alleged to havebeen caused directly or indirectly by this document.
Published: 2010
© 2010 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 2010 Benutzer- undReferenzhandbuch
1Altova UModel 2010
Inhaltsverzeichnis
1 UModel 3
2 Einführung in UModel 6
3 Was ist neu in UModel 8
4 UModel Tutorial 12
................................................................................................................. 144.1 Starten von UModel
................................................................................................................. 184.2 Use Cases
................................................................................................................. 274.3 Klassendiagramme
................................................................................................... 344.3.1 Erstellen von abgeleiteten Klassen
................................................................................................................. 394.4 Objektdiagramme
................................................................................................................. 454.5 Komponentendiagramme
................................................................................................................. 504.6 Deployment-Diagramme
................................................................................................................. 544.7 Round-Trip Engineering (Modell - Code - Modell)
................................................................................................................. 614.8 Round-Trip Engineering (Code - Modell - Code)
5 UModel Benutzeroberfläche 68
................................................................................................................. 695.1 Modell-Struktur
................................................................................................................. 745.2 Diagramm-Struktur
................................................................................................................. 765.3 Favoriten
................................................................................................................. 785.4 Eigenschaften
................................................................................................................. 805.5 Stile
................................................................................................................. 835.6 Hierarchie
................................................................................................................. 865.7 Übersicht - Dokumentation
................................................................................................................. 875.8 Dokumentation
................................................................................................................. 885.9 Meldungen
................................................................................................................. 895.10 Diagrammfenster
................................................................................................... 935.10.1 Diagrammeigenschaften
................................................................................................... 955.10.2 Ausschneiden, Kopieren und Einfügen in UModel Diagramme
Altova UModel 20102
................................................................................................................. 985.11 Hinzufügen/Einfügen von Modellelementen
................................................................................................................. 1015.12 Verknüpfen von Modellierungselementen
................................................................................................................. 1065.13 Bank-Beispieldateien
6 UModel Befehlszeilenschnittstelle 110
................................................................................................................. 1146.1 Datei: New / Load / Save-Optionen
7 Projekte und Code Engineering 116
................................................................................................................. 1197.1 Mini-UModel Projekt - von Grund auf neu erstellen
................................................................................................................. 1237.2 Importieren von Quellcode in Projekte
................................................................................................................. 1287.3 Importieren von Java-, C#- und VB-Binärdateien
................................................................................................................. 1347.4 Synchronisieren von Modell und Quellcode
................................................................................................... 1377.4.1 Tipps zur Synchronisierung
................................................................................................... 1397.4.2 Refactoring und Synchronisierung von Code
................................................................................................................. 1407.5 Voraussetzungen für Forward Engineering
................................................................................................................. 1427.6 Generieren von Java-Code aus UModel-Elementen und umgekehrt
................................................................................................................. 1437.7 Generieren von C#-Code aus UModel Elementen und umgekehrt
................................................................................................................. 1447.8 XML Schema von/zu UModel Elementen
................................................................................................................. 1457.9 Konvertierung VB.NET-Code - UModel-Elemente
................................................................................................................. 1467.10 Inkludieren anderer UModel-Projekte
................................................................................................................. 1487.11 Zusammenführen von UModel-Projekten
................................................................................................................. 1497.12 Freigeben von Paketen und Diagrammen
................................................................................................................. 1537.13 UML-Vorlagen
................................................................................................... 1557.13.1 Vorlagensignaturen
................................................................................................... 1567.13.2 Vorlagenverwendung
................................................................................................... 1577.13.3 Vorlagenverwendung in Operationen und Eigenschaften
................................................................................................................. 1587.14 Projekteinstellungen
................................................................................................................. 1597.15 Verbesserung der Performance
8 Erstellen von Modellbeziehungen 162
................................................................................................................. 1658.1 Assoziationen, Realisierungen und Abhängigkeiten
................................................................................................................. 1688.2 Anzeigen von Modellbeziehungen
9 Generieren von UML-Dokumentation 170
3Altova UModel 2010
10 UML-Diagramme 176
................................................................................................................. 17710.1 Verhaltensdiagramme
................................................................................................... 17810.1.1 Aktivitätsdiagramm
........................................................................................................... 179Einfügen von Aktivitätsdiagrammelementen
........................................................................................................... 181Erstellen von Verzweigungen und Merges
........................................................................................................... 183Aktivitätsdiagramm-Elemente
................................................................................................... 19210.1.2 Zustandsdiagramm
........................................................................................................... 193Einfügen von Zustandsdiagrammelementen
........................................................................................................... 193Erstellen von Zuständen, Aktivitäten und Transitionen
........................................................................................................... 198Zusammengesetzte Zustände
........................................................................................................... 201Zustandsdiagramm-Elemente
................................................................................................... 20410.1.3 Protokoll-Zustandsautomat
........................................................................................................... 205Einfügen von Protokoll-Zustandsdiagramm-Elementen
........................................................................................................... 206Protokoll-Zustandsdiagramm-Elemente
................................................................................................... 20910.1.4 Use Case-Diagramm
................................................................................................... 21010.1.5 Kommunikationsdiagramm
........................................................................................................... 210Einfügen von Kommunikationsdiagrammelementen
................................................................................................... 21410.1.6 Interaktionsübersichtsdiagramm
........................................................................................................... 215Einfügen von Interaktionsübersichtselementen
................................................................................................... 21910.1.7 Sequenzdiagramm
........................................................................................................... 220Einfügen von Sequenzdiagrammelementen......................................................................................................................................... 221Lebenslinie......................................................................................................................................... 223Combined Fragment......................................................................................................................................... 226Interaction Use......................................................................................................................................... 226Gate......................................................................................................................................... 227Zustandsinvariante......................................................................................................................................... 227Nachrichten
........................................................................................................... 232Generieren von Sequenzdiagrammen anhand von Quellcode
........................................................................................................... 235Generieren von Sequenzdiagrammen anhand vonEigenschaften
................................................................................................... 23810.1.8 Zeitverlaufsdiagramm
........................................................................................................... 239Einfügen von Elementen des Zeitverlaufsdiagramms
........................................................................................................... 239Lebenslinie
........................................................................................................... 241Tick-Symbol
........................................................................................................... 242Auslösendes Ereignis
........................................................................................................... 243Zeitdauerbedingung
........................................................................................................... 243Zeitbedingung
........................................................................................................... 244Nachricht
................................................................................................................. 24610.2 Strukturdiagramme
................................................................................................... 24710.2.1 Klassendiagramm
Altova UModel 20104
................................................................................................... 25810.2.2 Kompositionsstrukturdiagramm
........................................................................................................... 258Einfügen von Elementen einesKompositionsstrukturdiagramms
................................................................................................... 26110.2.3 Komponentendiagramm
................................................................................................... 26210.2.4 Deployment-Diagramm
................................................................................................... 26310.2.5 Objektdiagramm
................................................................................................... 26410.2.6 Paketdiagramm
........................................................................................................... 265Einfügen von Paketdiagrammelementen
................................................................................................... 26710.2.7 Profildiagramm und Stereotype
........................................................................................................... 269Hinzufügen von Stereotypen und Definieren vonEigenschaftswerten
........................................................................................................... 273Stereotype und Enumerationen
........................................................................................................... 275Benutzerdefinierte Stereotypstile
................................................................................................................. 27710.3 Zusätzliche Diagramme
................................................................................................... 27810.3.1 XML-Schema-Diagramme
........................................................................................................... 279Importieren von XML-Schemas
........................................................................................................... 285Einfügen von XML-Schema-Elementen
........................................................................................................... 289Erstellen und Generieren eines XML-Schemas
11 Austausch von Metadaten zwischen XMI undXML 292
12 Versionskontrolle 296
................................................................................................................. 29812.1 Unterstützte Versionskontrollsysteme
................................................................................................................. 30312.2 Installation von Versionskontrollsystemen
................................................................................................................. 31012.3 Versionskontrolle und Vergleich mit Altova DiffDog
................................................................................................................. 31612.4 Versionskontrollbefehle
................................................................................................... 31712.4.1 Aus Versiopskontrolle öffnen
................................................................................................... 31912.4.2 Versionskontrolle aktivieren
................................................................................................... 32012.4.3 Aktuellste Version holen
................................................................................................... 32112.4.4 Abrufen
................................................................................................... 32212.4.5 Ordner abrufen
................................................................................................... 32312.4.6 Auschecken
................................................................................................... 32512.4.7 Einchecken
................................................................................................... 32612.4.8 Auschecken rückgängig...
................................................................................................... 32712.4.9 Zu Versionskontrolle hinzufügen
................................................................................................... 32912.4.10 Von Verionskontrolle ausgliedern
................................................................................................... 33012.4.11 Aus Versionskontrolle freigeben
................................................................................................... 33112.4.12 Verlauf anzeigen
5Altova UModel 2010
................................................................................................... 33312.4.13 Unterschiede anzeigen
................................................................................................... 33512.4.14 Eigenschaften anzeigen
................................................................................................... 33612.4.15 Status aktualisieren
................................................................................................... 33712.4.16 Versionskontrollmanager
................................................................................................... 33812.4.17 Versionskontrolle wechseln
13 UModel Diagrammsymbole 340
................................................................................................................. 34113.1 Aktivitätsdiagramm
................................................................................................................. 34213.2 Klassendiagramm
................................................................................................................. 34313.3 Kommunikationsdiagramm
................................................................................................................. 34413.4 Kompositionsstrukturdiagramm
................................................................................................................. 34513.5 Komponentendiagramm
................................................................................................................. 34613.6 Deployment-Diagramm
................................................................................................................. 34713.7 Interaktionsübersichtsdiagramm
................................................................................................................. 34813.8 Objektdiagramm
................................................................................................................. 34913.9 Paketdiagramm
................................................................................................................. 35013.10 Profildiagramm
................................................................................................................. 35113.11 Sequenzdiagramm
................................................................................................................. 35213.12 Zustandsdiagramm
................................................................................................................. 35313.13 Zeitverlaufsdiagramm
................................................................................................................. 35413.14 Use Case-Diagramm
................................................................................................................. 35513.15 XML-Schema-Diagramm
14 UModel Referenz 358
................................................................................................................. 35914.1 Datei
................................................................................................................. 36414.2 Bearbeiten
................................................................................................................. 36714.3 Projekt
................................................................................................................. 37714.4 Layout
................................................................................................................. 37814.5 Ansicht
................................................................................................................. 37914.6 Extras
................................................................................................... 38014.6.1 Anpassen...
........................................................................................................... 380Befehle
........................................................................................................... 380Symbolleisten
........................................................................................................... 381Extras
........................................................................................................... 384Tastatur
........................................................................................................... 384Menü
........................................................................................................... 385Optionen
Altova UModel 20106
................................................................................................... 38614.6.2 Optionen
................................................................................................................. 39314.7 Fenster
................................................................................................................. 39414.8 Hilfe
15 Code Generator 396
................................................................................................................. 39715.1 Der Weg zu SPL (Spy Programming Language)
................................................................................................... 39815.1.1 Grundlegende SPL-Struktur
................................................................................................... 39915.1.2 Variablen
................................................................................................... 40515.1.3 Operatoren
................................................................................................... 40615.1.4 Bedingungen
................................................................................................... 40715.1.5 foreach
................................................................................................... 40815.1.6 Subroutinen
........................................................................................................... 408Deklaration einer Subroutine
........................................................................................................... 409Subroutinenaufruf
................................................................................................................. 41015.2 Fehlercodes
16 Anhänge 412
................................................................................................................. 41316.1 Lizenzinformationen
................................................................................................... 41416.1.1 Electronic Software Distribution
................................................................................................... 41516.1.2 Software-Aktivierung und Lizenzüberwachung
................................................................................................... 41616.1.3 Rechte am geistigen Eigentum
................................................................................................... 41716.1.4 Altova Endbenutzer-Lizenzvereinbarung
Index
© 2010 Altova GmbH
3UModel
Altova UModel 2010
1 UModel
UModel®2010 Professional 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.3 Spezifikation. UModel ist eine 32/64-BitWindows-Applikation, die auf Windows Server 2003/2008, Windows XP, Windows Vista undWindows 7 läuft. Die 64-Bit-Version steht für die Enterprise und die Professional Version zurVerfügung.
UModel® 2010 unterstützt:
alle 14 UML 2.3 Modellierungsdiagramme Protokoll-Zustandsdiagramme SysML-1.1-Diagramme (nur Enterprise Version) Sequenzdiagrammgenerierung direkt anhand von Quellcode UModel API und Plugin (nur Enterprise Edition) Integrierte Skripting-Umgebung und Formulareditor (nur Enterprise Edition) Visual Studio Integration (nur Enterprise Edition) Eclipse Integration (nur Enterprise Edition) Unterstützung für Versionskontrollsysteme XML-Schema-Diagramme Business Process Modeling Notation (nur Enterprise Edition) Mehrere Ebenen bei UML-Diagrammen (nur Enterprise Edition) Import von Java-, C#- und Visual Basic-Binärdateien Verknüpfen von Diagrammen und Modellierungselementen mittels Hyperlinks Syntaxfärbung in Diagrammen Cascading Styles unbegrenztes Rückgängigmachen und Wiederherstellen Generierung von Java-, C#- und Visual Basic-Code anhand von Modellen Reverse Engineering von vorhandenem Java-, C#- und Visual Basic-Quellcode vollständiges Round-Trip Engineering mit Zusammenführung von Code und Modell XMI-Version 2.1.1 für UML 2.0, 2.1und 2.1.2, 2.2, 2.3-Modellimport und -export Generierung von UModel Projektdokumentation
Dank dieser Funktionen können Entwickler - selbst Neulinge im Bereich derSoftware-Modellierung - rasch das volle Potenzial von UML ausschöpfen, um produktiverarbeiten und optimale Ergebnisse erzielen zu können.
4 UModel
© 2010 Altova GmbHAltova UModel 2010
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.
6 Einführung in UModel
© 2010 Altova GmbHAltova UModel 2010
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ührtwerden kann.
Die Codegenerierung ist anpassbar: Die Codegenerierung in UModel basiert aufSPL-Vorlagen und kann daher komplett angepasst werden. Änderungen werdenautomatisch bei der Codegenerierung erkannt.
Bei der Codegenerierung und dem Reverse Engineering werden derzeit die JavaVersionen 1.4x, 5.0 und 1.6, die C#-Versionen 1.2, 2.0, 3.0 und 4.0 und die VisualBasic Versionen 7.1, 8.0 und 9.0 unterstützt. Ein einziges Projekt kann gleichzeitigsowohl Java-, C#- oder VB-Code unterstützen.
Unterstützung für UML-Vorlagen und Generics.
XML-Metadaten-Austausch (XML-Version 2.1.1) für UML 2.0 / 2.1.1 /2.1.2 / 2.2 / 2.3
Beim Hinzufügen von Eigenschaften oder Operationen bietet UModel Eingabehilfen zurAuswahl von Typen, Spezialisierung und Klassifizierung und allen anderen Arten vonEigenschaften, die auch in gängigen IDEs wie XMLSpy, Visual Studio oder Eclipse zurVerfügung stehen.
Dank der Syntaxfärbung in Diagrammen werden UML-Diagramme attraktiver undintuitiver.
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.
Die Funktion zum unbegrenzten Rückgängigmachen und Wiederherstellen hält nichtnur Änderungen am Inhalt fest, sondern auch alle Änderungen am Stil vonModellelementen.
Bitte beachten Sie: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.
8 Was ist neu in UModel
© 2010 Altova GmbHAltova UModel 2010
3 Was ist neu in UModel
Die Version 2010 Release 3 von UModel bietet die folgenden neuen Funktionen undVerbesserungen:
Unterstützung für Visual Studio 2010: Unterstützung neuer Lösungs- undProjektdateien, Bereitstellung vordefinierter include-Dateien für .NET Framework 4.0
Unterstützung für C# 4.0: Unterstützung neuer C# 4.0-Funktionen bei Round-TripEngineering, binärem Datenimport und Sequenzdiagrammgenerierung
Funktionen zum Erstellen von Protokoll-Zustandsautomaten Neue Option für die Ausgabe mit automatischem Layout: Block Möglichkeit, Operationsnamen bei der Generierung von Sequenzdiagrammen zu
ignorieren Möglichkeit, Argumentvariablen für externe Tools zu definieren
Die Version 2010 Release 2 von UModel bietet die folgenden Verbesserungen:
64-Bit-Unterstützung Unterstützung für UML 2.3 Möglichkeit, generierte Sequenzdiagramme automatisch in kleinere Subdiagramme
aufzuteilen Die generierte HTML-Dokumentation enthält auch manuell definierte Hyperlinks
zwischen Elementen Erstellung separater Diagramme für den getter- oder setter-Teil einer Eigenschaft (C#
oder VB.NET)
Bitte beachten Sie: Aufgrund der neuen UML-Version 2.3 (nähere Informationen dazu siehe Projekte undCode Engineering für Java / C# / VB.NET Code von/in UModel) wurden die folgendenÄnderungen vorgenommen:
Die Class Modifiers “sealed” (C#), “NotInheritable” (VB.NET) und “final” (Java) wurdennun in UML “isFinalSpecification” zugeordnet.
Der Java Modifier “final” für Felder und Methoden wurde nun in UML “leaf” zugeordnet.
Die Version 2010 von UModel bietet die folgenden neuen Funktionen und Verbesserungen:
Code Engineering: Funktion zum Auflösen von Aliassen beim Reverse Engineering von Code Kleinere Verbesserungen bei der Generierung von Sequenzdiagrammen
Benutzeroberfläche: In das Dokumentationsfenster eingegebene Kommentare können nun in
Diagrammen angezeigt/bearbeitet werden Eigenschaftswerte können nun in Klassen, Schnittstellen usw. in neuen Bereichen
angezeigt werden Hyperlinks können nun im Fenster Dokumentation definiert werden In der Modell-Struktur können Hyperlinks zu Elementen erstellt werden Möglichkeit der Anzeige von UML-Enthältbeziehungslinien
Dokumentationsgenerierung: Speichern von CSS-Code in HTML-Dateien oder extern Generierte Bilddateien können in einem bestimmten Unterverzeichnis gespeichert
© 2010 Altova GmbH
9Was ist neu in UModel
Altova UModel 2010
werden
Dateisystem: Kopie speichern unter wird nun unterstützt
Die Version 2009 von UModel bietet die folgenden Funktionen und Verbesserungen:
Unterstützung für UML 2.2
Generierung von Sequenzdiagrammen direkt anhand von Quellcode
Unterstützung für Versionskontrollsysteme in der Standalone-Version
Neues UML-Profildiagramm
Ermittlung und Behandlung von Typen und Namespaces beim Refactoring von Code
Gehe zu Funktion für Lebenslinien und Sequenzdiagramme
Verbesserte Anzeige des Fensters "Hierarchie".
Möglichkeit UModel-Projektdateien im "Pretty Print"-Format zu speichern
Verbesserte Funktion zur Erstellung einer Teildokumentation
Funktionen zum Öffnen von UModel-Projekten über eine URL
Funktion zum Laden/Speichern offener Diagramme mit der Projektdatei
Die Version 2008 Release 2 bietet die folgenden Funktionen und Verbesserungen:
Unterstützung für Visual Basic .NET 9.0 und C# 3.0 sowie Visual Studio 2008, Java 1.6
Das Zusammenführen von Projekten wird nun unterstützt
Benutzerdefinierte Stereotypenstile und deren Definition
Verbesserte Autokomplettierungsfunktionen
Automatische Generierung von Komponentenrealisierungen
Import mehrerer XML-Schemas aus einem Verzeichnis
Automatische Generierung von Namespace-Verzeichnissen für generierten Code
Unterstützung für Objektknoten in Aktivitätsdiagrammen
Funktion zum Generieren relativer Links für UML-Dokumentation
UML-konforme Sichtbarkeitssymbole in Klassendiagramme
Unterstützung für Collection-Assoziationen
Die Version 2008 von UModel beinhaltet die folgenden neuen bzw. verbesserten Features:
Generierung von Visual Basic-Code anhand von Modellen und Reverse Engineeringvon Visual Basic Code.
Funktion zum Speichern aller Projektdiagramme auf einmal.
Mehrzeilige Titel für Lebenslinien in Sequenz-, Kommunikations- undZeitverlaufsdiagrammen.
10 Was ist neu in UModel
© 2010 Altova GmbHAltova UModel 2010
Unterstützung von Ereignisunterelementen in Zustandsdiagrammen:ReceiveSignalEvent, SignalEvent, SendSignalEvent, ReceiveOperationEvent,SendOperationEvent und ChangeEvent.
Neue Option 'Gehe zu Operation' bei Call-Nachrichten in Sequenz- undKommunikationsdiagrammen.
Signale können nun Generalisierungen und eigene Attribute haben.
Verbesserte Unterstützung für Eigenschaftswerte
Funktion zum Suchen und Ersetzen von Modellierungselementen.
Sequenzdiagramme: Automatische Generierung von (syntaktisch korrekten) Antworten, wenn Nachrichten zu
Sequenzdiagrammen hinzugefügt werden.
Namen von statischen Operationen sind in Sequenzdiagrammen unterstrichen.
Verbessertes Dialogfeld "Operationen überschreiben / implementieren". Operationen aus gebundenen Vorlagen können sichtbar gemacht und überschrieben
werden
Es wird angezeigt, welche Operationen abstrakt oder nicht definiert sind
12 UModel Tutorial
© 2010 Altova GmbHAltova UModel 2010
4 UModel Tutorial
In diesem Tutorial wird der Reihe nach beschrieben, wie man im Allgemeinen beim Erstelleneines Modellierungsprojekts in UModel vorgeht.
Der Großteil des Tutorials ist dem Forward Engineering gewidmet, d.h. dem Erstellen vonUML-Diagrammen in UModel und dem Generieren von Code. Anschließend wird auf dasRound-Trip Engineering eingegangen. In den Abschnitten über Round-Trip Engineering wirdder Vorgang sowohl 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) Klassendiagramme Objektdiagramme Komponentendiagramme Deployment-Diagramme (Verteilungsdiagramme)
Round-Trip Engineering (Modell - Code - Modell) Codegenerierung von UModel Hinzufügen einer neuen Operation zum externen Code Überführen des externen Codes in UModel.
Round-Trip Engineering (Code - Modell - Code) Importieren von mit XMLSpy erzeugtem Code aus einem Verzeichnis (oder einer
Projektdatei) Hinzufügen einer neuen Klasse zum generierten Modell in UModel Zusammenführen des aktualisierten Projekts mit dem externen Code.
Alle in diesem Tutorial verwendeten Beispiele stehen anfangs im Ordner C:\Documents 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 denOrdner C:\Documents and Settings\<username>\MyDocuments\Altova\UModel2010\UModelExamples\ kopiert. Verschieben, bearbeiten oderlöschen Sie daher die Beispieldateien im 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 nachund nach neue Pakete, Modelldiagramme und viele andere Elemente hinzugefügt, umIhnen zu demonstrieren, wie leicht Sie mit UModel Applikationen modellieren können.Beachten Sie bitte, dass die Syntaxüberprüfung bei dieser Datei Fehler undWarnmeldungen ausgibt. Im Tutorial wird beschrieben, wie Sie diese Problemebeheben können.
BankView-finish.umpist die UModel Projektdatei, in der Sie das Tutorial-Beispiel im Endzustand sehen.Diese Projektdatei wird beim Generieren von Code und beim Synchronisieren desCodes mit UModel verwendet.
© 2010 Altova GmbH
13UModel Tutorial
Altova UModel 2010
Der OrgChart.zip-Ordner in diesem Ordner wird für das Round-Trip Engineeringverwendet. Entpacken Sie den Ordner bitte in den Ordner ..\UmodelExamples, bevorSie mit dem Abschnitt beginnen.
Weitere Beispieldateien sowohl für die Programmiersprache Java als auch C# liegen ebenfallsim selben 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 Projektvon Grund auf neu erstellt und Code generiert.
14 UModel Tutorial Starten von UModel
© 2010 Altova GmbHAltova UModel 2010
4.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 nuneinige vordefinierte Pakete. Beachten Sie, dass das Hauptfenster zu diesem Zeitpunktleer ist.
© 2010 Altova GmbH
Starten von UModel 15UModel Tutorial
Altova UModel 2010
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 derStandard-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 Projektstruktursich diese 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 aktuellausgewählten Elements aus dem Fenster "Modell-Struktur" oder "Diagramm". Aufdiesem Register kö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 allgemeineGruppen unterteilen: Formatierungen und Anzeigeeinstellungen.
Auf dem Register Hierarchie sehen Sie alle Beziehungen des aktuell ausgewählten
16 UModel Tutorial Starten von UModel
© 2010 Altova GmbHAltova UModel 2010
Modellierungselements 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.
Auf dem Register Ebene können Sie mehrere Ebenen für die einzelnen UModelDiagramme definieren. Es können sowohl einzelne als auch mehrere Ebeneneingeblendet, gesperrt und ausgeblendet werden. Mit Hilfe von Ebenen können Sie dieModellierungselemente in einem Diagramm in logische Gruppen einteilen.
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 generiertwird)
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
Akteuer (sichtbar im aktiven Use Case-Diagramm)
© 2010 Altova GmbH
Starten von UModel 17UModel Tutorial
Altova UModel 2010
Use Case
Komponente
Knoten
Artefakt
Schnittstelle
Beziehungen (/Paket)Einschränkungen
18 UModel Tutorial Use Cases
© 2010 Altova GmbHAltova UModel 2010
4.2 Use Cases
Altova Website: UML Use Case-Diagramme
Ziel dieses Tutorial-Abschnitt ist es:
ein neues Paket zum Projekt hinzuzufügen ein neues Use Case-Diagramm zum Projekt hinzuzufügen Use Case-Elemente zum Diagramm hinzuzufügen und die Abhängigkeiten zwischen
den Elementen zu definieren Elemente auf dem Diagramm-Register auszurichten und deren Größe anzupassen.
So fügen Sie ein neues Paket zu einem Projekt hinzu:1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf das Root-Paket und wählen
Sie Neues Element | Paket.2. Geben Sie den Namen des neuen Pakets ein, z.B. Use Case View und drücken Sie die
Eingabetaste.
Nähere Informationen zu Paketen und ihren Eigenschaften finden Sie unter "Pakete".
So fügen Sie ein Diagramm zu einem Paket hinzu:1. Rechtsklicken Sie auf das zuvor erstellte Paket "Use Case View".2. Wählen Sie den Befehl Neues Diagramm | UseCase-Diagramm.
© 2010 Altova GmbH
Use Cases 19UModel Tutorial
Altova UModel 2010
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 Sieihn in "Overview Account Balance" und drücken Sie die Eingabetaste.
Nähere Informationen zu Diagrammen und deren Eigenschaften finden Sie unter Diagramme.
So fügen Sie Use Case-Elemente zum Use Case-Diagramm hinzu:1. Rechtsklicken Sie in das neu erstellte Diagramm und wählen Sie Neu | Akteur.
Das Akteurelement wird an der Mausposition eingefügt.
2. Klicken Sie auf das Use Case-Symbol in der Symbolleiste und dann in 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.
20 UModel Tutorial Use Cases
© 2010 Altova GmbHAltova UModel 2010
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 mehrzeiligenUse Case-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".
© 2010 Altova GmbH
Use Cases 21UModel Tutorial
Altova UModel 2010
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.Die Eigenschaften der Assoziation sind auch auf dem Register "Eigenschaften" zusehen. Die neue Assoziation wurde unter dem Element "Beziehungen" des Use CaseView-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.
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 Textfeld
22 UModel Tutorial Use Cases
© 2010 Altova GmbHAltova UModel 2010
angepasst, 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 denextension-Bereich auszublenden.
5. Klicken Sie auf den Akteur und erstellen Sie mit Hilfe des Assoziationsziehpunkts eineAssoziation zwischen "Standard User" und "get account balance sum".
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
© 2010 Altova GmbH
Use Cases 23UModel Tutorial
Altova UModel 2010
Case-Ellipse (unter der Ellipse) und ziehen Sie die Abhängigkeit auf "get accountbalance".
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. Bei Auswahl von "Vorschau" wird im Dialogfeld eine Vorschau derausgewählten Datei angezeigt.
24 UModel Tutorial Use Cases
© 2010 Altova GmbHAltova UModel 2010
6. Klicken Sie auf OK, um die Einstellungen zu bestätigen und fügen Sie den neuenAkteur ein.
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, hatdie RGB-Werte 82.82.82.
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 undim Übersichtsfenster strichliert angezeigt wird.
© 2010 Altova GmbH
Use Cases 25UModel Tutorial
Altova UModel 2010
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.
Bitte beachten Sie:Sie können auch mit Hilfe der Strg-Taste mehrere Elemente auswählen.
© 2010 Altova GmbH
Klassendiagramme 27UModel Tutorial
Altova UModel 2010
4.3 Klassendiagramme
Altova Website: UML-Klassendiagramme
Ziel dieses Tutorial-Abschnitts ist es:
eine neue abstrakte Klasse mit dem Namen "Account" sowie Attribute undOperationen hinzuzufügen
eine Kompositions-Assoziation von Bank zu Account zu erstellen
So öffnen Sie ein anderes Diagramm in UModel:1. Klicken Sie auf das Register "Diagramm-Struktur".2. Erweitern Sie das Paket "Klassendiagramme", um dessen Inhalt zu sehen.
Es werden nun alle im Projekt vorhandenen Klassendiagramme angezeigt.
3. Doppelklicken Sie auf das Diagrammsymbol BankView Main.Das Klassendiagramm wird in Form eines Registers im Arbeitsbereich angezeigt.
Bitte beachten Sie:Sie können natürlich auch auf dem Register "Modell-Struktur" auf dasKlassendiagrammsymbol unterhalb des Pakets "BankView" doppelklicken, umdasselbe Ergebnis zu erzielen.
Im Klassendiagramm sehen Sie zwei konkrete Klassen, die durch eineKompositions-Assoziation verbunden sind.
28 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
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ätigendie Eingabetaste, (doppelklicken Sie auf den Namen, wenn er nicht mehr aktiv ist).
Beachten Sie, dass die Eigenschaften der aktuellen Klasse auf dem Register"Eigenschaften" angezeigt werden.
3. Aktivieren Sie im Bereich "Eigenschaften" das Kontrollkästchen "abstrakt", um 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.
© 2010 Altova GmbH
Klassendiagramme 29UModel Tutorial
Altova UModel 2010
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 denRückgabewert-Datentyp "float" einzufügen.Beachten Sie bitte, dass die Groß- und Kleinschreibung in Dropdown-Listen eine Rollespielt!
30 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
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.7. Wählen Sie aus der Dropdown-Liste IBankAPI aus, fügen Sie die schließende
© 2010 Altova GmbH
Klassendiagramme 31UModel Tutorial
Altova UModel 2010
Klammer ")" hinzu und geben Sie einen Doppelpunkt ":" ein.
8. Drücken Sie die Taste "b", um den Booleschen Datentyp auszuwählen und fügen Sieihn anschließend durch Drücken der Eingabetaste ein.
9. Drücken Sie die Eingabetaste, um die Definition zu beenden.
Bitte beachten Sie:
Wenn Sie auf das Ein-/Ausblendsymbol links von einer Operation oder
Eigenschaft klicken, wird eine Dropdown-Liste geöffnet, über die Sie denSichtbarkeitsstatus ändern können. Beachten Sie, dass diese Ein-/Ausblendsymbole indie UML-konformen Symbole geändert werden können.
Löschen von Klasseneigenschaften und Operationen aus einem Klassendiagramm:1. Drücken Sie F8 und dann die Eingabetaste um eine Standardoperation "Operation1"
zur Klasse "Account" hinzuzufügen.2. Klicken Sie auf Operation1 und drücken Sie die Entf-Taste, um die Operation zu
löschen.
Es erscheint eine Meldung, in der Sie gefragt werden, ob das Element aus dem 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, nichtaber aus dem Projekt, drücken Sie Strg + Entf. Sie können auch eineBestätigungsmeldung aktivieren, die Sie beim Löschen von Objekten bestätigen
32 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
müssen. Nähere Informationen dazu finden Sie unter Extras | Beearbeiten"
Suchen (Löschen) von Klasseneigenschaften und Optionen aus der Modell-Struktur:Eigenschaften und Optionen können auch direkt aus der Modell-Struktur gelöscht werden.Dazu müssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1"in die Klasse "Account" eingefügt (drücken Sie zum Einfügen F8 und anschließend dieEingabetaste):
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 beneihe jedes Modellierungselement inder Modell-Struktur finden können.
Bitte beachten Sie: Sie können beim Anzeigen von Attributeigenschaften auch vom Fenster"Eigenschaften" zur Modell-Struktur navigieren. Nähere Informationen dazu finden Siein der Benutzerreferenz unter Eigenschaften.
Erstellen einer Kompositions-Assoziation zwischen den Klassen "Bank" und "Account":
1. Klicken Sie in der Titelleiste auf das Symbol "Komposition" und ziehen Sie es 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.
© 2010 Altova GmbH
Klassendiagramme 33UModel Tutorial
Altova UModel 2010
2. Doppelklicken Sie in der Klasse "Bank" auf den neuen Eintrag Property1 und ändernSie ihn 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.
34 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
4.3.1 Erstellen von abgeleiteten Klassen
Ziel dieses Tutorialabschnitts ist es:
Hinzufügen eines neuen Klassendiagramms namens "Account Hierarchy" zum Projekt Einfügen bestehender Klassen und Erstellen einer Klasse "Savings account" Erstellen von drei abgeleiteten Klassen der abstrakten Basisklasse "Account" mit Hilfe
von Generalisierungen
So erstellen Sie ein neues Klassendiagramm:1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf das Paket "bankview" (unter
Design-phase | BankView | com | altova) und wählen Sie Neues Diagramm |Klassendiagramm.
2. Doppelklicken Sie auf den neuen Eintrag Klassendiagramm1, benennen Sie ihn in"Account Hierarchy" um und drücken Sie die Eingabetaste.
Im Arbeitsbereich wird nun das Register "Account Hierarchy" angezeigt.
Einfügen von bestehenden Klassen in ein Diagramm:1. Klicken Sie im Paket bankview auf die Klasse Account (unter com | altova | bankview
) und
2. Ziehen Sie sie auf das Register "Account Hierarchy".3. Klicken Sie auf die Klasse CheckingAccount (im selben Paket) und ziehen Sie diese
© 2010 Altova GmbH
Klassendiagramme 35UModel Tutorial
Altova UModel 2010
ebenfalls auf das Register.4. Platzieren Sie die Klasse links unterhalb der Klasse "Account".5. Fügen Sie auf dieselbe Art die Klasse CreditCardAccount ein. Platzieren Sie sie
rechts von der Klasse CheckingAccount.
Hinzufügen einer neuen Klasse:1. Rechtsklicken Sie auf den Diagrammhintergrund (rechts von der Klasse
"CreditAccount") und wählen Sie Neu | Klasse.Daraufhin wird automatisch eine neue Klasse zum richtigen Paket hinzugefügt, also zubankview, welches das aktuelle Klassendiagramm Account Hierarchy enthält.
2. Doppelklicken Sie auf den Klassennamen und ändern Sie ihn in SavingsAccount.
36 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
3. Drücken Sie F7 und fügen Sie eine neue "Property" (Eigenschaft) hinzu.4. Geben Sie "interestRate" gefolgt von einem Doppelpunkt ein und drücken Sie "f", um
den Datentyp "float" aus der Dropdown-Liste auszuwählen. Drücken Sie zweimal 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 denStandard-Tastenkombinationen von einer Klasse in die andere kopiert oder verschoben
© 2010 Altova GmbH
Klassendiagramme 37UModel Tutorial
Altova UModel 2010
werden. Dies funktioniert in folgenden Fällen: innerhalb einer Klasse auf dem Diagramm-Register zwischen verschiedenen Klassen auf dem Diagramm-Register in der Modell-Struktur-Ansicht zwischen verschiedenen UML-Diagrammen durch Ziehen der kopierten Daten auf ein
anderes Diagrammregister. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren und Einfügen inUModel Diagrammen.
1. Erweitern Sie die Klasse Account in der Modell-Struktur.2. Rechtsklicken Sie auf die Operation collectAccountInfo und wählen Sie Kopieren.
3. Rechtsklicken Sie in der Modell-Struktur auf die Klasse SavingsAccount und wä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"zu sehen.
Bitte beachten Sie:Sie können diese Ergebnisse in der Modell-Struktur sowohl mit Kopieren/Einfügen (StrgC bzw. V) als auch mit Drag & Drop erzielen. Eventuell müssen Sie die Sortieroptionen
38 UModel Tutorial Klassendiagramme
© 2010 Altova GmbHAltova UModel 2010
deaktivieren, 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 dreiabgeleitete konkrete Klassen erstellen.
1. Klicken Sie in der Symbolleiste auf das Symbol "Generalisierung" und halten Siedie Strg-Taste gedrückt.
2. Ziehen Sie den Cursor von CreditCardAccount (der Klasse in der Mitte) in die Klasse"Account".
3. Ziehen Sie die Pfeilspitze von der Klasse CheckingAccount auf die zuvor 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.
© 2010 Altova GmbH
Objektdiagramme 39UModel Tutorial
Altova UModel 2010
4.4 Objektdiagramme
Altova Website: UML-Objektdiagramme
Ziel dieses Tutorialabschnittes ist es:
zu zeigen, wie Klassen- und Objektdiagramme in einem Diagramm kombiniertwerden können, um einen Schnappschuss des Objekts zu einem bestimmten Zeitpunktzu erhalten.
Objekte/Instanzen zu erstellen und die Beziehungen zwischen diesen zu definieren Assoziationen/Objektbeziehungen zu formatieren reale Daten in Objekte/Instanzen einzugeben
So öffnen Sie das Objektdiagramm:1. Doppelklicken Sie auf das Sample Accounts-Diagrammsymbol unter dem 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.
40 UModel Tutorial Objektdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Objektdiagramme 41UModel Tutorial
Altova UModel 2010
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 undwählen Sie 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" aufdas Register "Sample Accounts" und platzieren Sie es unterhalb von "John's credit".
42 UModel Tutorial Objektdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 classifierund wä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 beidenObjekte zu 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 Savingund AltovaBank.
© 2010 Altova GmbH
Objektdiagramme 43UModel Tutorial
Altova UModel 2010
Bitte beachten Sie:Änderungen, die in einem Klassendiagramm am Assoziationstyp vorgenommenwerden, 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 gebenSie als Kontostand 11,975.00 ein (englische Dezimalschreibweise).
3. Füllen Sie den Rest der Daten aus, um den Status der aktuellen Instanz zu sehen.
© 2010 Altova GmbH
Komponentendiagramme 45UModel Tutorial
Altova UModel 2010
4.5 Komponentendiagramme
Ziel dieses Tutorialabschnittes ist:
zu zeigen, wie Klassen in ein Komponentendiagramm eingefügt werden Realisierungsbeziehungen zwischen den Klassen und der Komponente "BankView" zu
erstellen zu zeigen, wie Zeileneigenschaften geändert werden Komponenten in ein Komponentendiagramm einzufügen und
Verwendungsbeziehungen zu einer Schnittstelle zu erstellen
So öffnen Sie ein Komponentendiagramm:1. Klicken Sie auf das Register "Diagramm-Struktur", erweitern Sie die Komponente
Komponentendiagramme und doppelklicken Sie auf das "BankViewrealization"-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 dembankview-Paket.
2. Ziehen Sie sie in das Komponentendiagramm.Die Klasse wird mit allen ihren Bereichen angezeigt.
46 UModel Tutorial Komponentendiagramme
© 2010 Altova GmbHAltova UModel 2010
3. Klicken Sie auf beide Einklappsymbole, bis nur mehr der Bereich mit demKlassennamen angezeigt wird.
4. Fügen Sie auf dieselbe Weise die abstrakte Klasse Account ein.
Bitte beachten Sie:Das Paket, das die eingefügte Klasse enthält, wird im Namensbereich in der Form"from bankview" angezeigt.
So erstellen Sie Realisierungsbeziehungen zwischen einer Klasse und einerKomponente:
1. Klicken Sie in der Symbolleiste auf das Realisierungssymbol .2. Ziehen Sie den Pfeil von SavingsAccount auf die Komponente BankView.
© 2010 Altova GmbH
Komponentendiagramme 47UModel Tutorial
Altova UModel 2010
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 Linienartklicken, 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 kleineSymbole, so genannte Wegpunkte angezeigt. Sie können darauf klicken und sie
48 UModel Tutorial Komponentendiagramme
© 2010 Altova GmbHAltova UModel 2010
verschieben, 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 dieaktuell definierten Systembeziehungen zwischen Komponenten und Schnittstellenangezeigt.
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:
1. Klicken Sie in der Symbolleiste auf das Symbol "Verwendung" .
© 2010 Altova GmbH
Komponentendiagramme 49UModel Tutorial
Altova UModel 2010
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".
50 UModel Tutorial Deployment-Diagramme
© 2010 Altova GmbHAltova UModel 2010
4.6 Deployment-Diagramme
Ziel dieses Tutorialabschnittes ist es:
die Artefakt-Manifestation von Komponenten zu zeigen einen neuen Knoten und eine Abhängigkeit zu einem Deployment-Diagramm
(Verteilungsdiagramm) hinzuzufügen Artefakte zu einem Knoten hinzuzufügen und Beziehungen zwischen diesen zu
erstellen
So öffnen Sie das Deployment-Diagramm (Artefakte):1. Klicken Sie auf das Register "Modell-Struktur", erweitern Sie das Deployment View
-Diagrammpaket und doppelklicken Sie auf das Artefakt-Symbol.
In diesem Diagramm sehen Sie die Manifestation der Komponenten Bank API clientund BankView zu ihren jeweiligen kompilierten .jar-Java-Dateien.
So öffnen Sie das Deployment-Diagramm:1. Doppelklicken Sie auf das Deployment-Symbol unter dem Deployment View-Paket.
Daraufhin wird das Deployment-Diagramm geöffnet und die physische Architektur desSystems wird angezeigt, welches derzeit nur den Knoten "Home PC" enthält.
© 2010 Altova GmbH
Deployment-Diagramme 51UModel Tutorial
Altova UModel 2010
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-Knoten zum Bank-Knoten.Dadurch wird eine Abhängigkeit zwischen den beiden Knoten erstellt.
2. Klicken Sie auf dem Register "Eigenschaften" in das Feld name, ändern Sie es inTCP/IP und drücken Sie zum Bestätigen die Eingabetaste.Der Name der Abhängigkeit wird oberhalb der Abhängigkeitslinie angezeigt.
52 UModel Tutorial Deployment-Diagramme
© 2010 Altova GmbHAltova UModel 2010
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 dasFeld "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-Artekfakte und platzieren Sie sie auf den Diagrammhintergrund (Fürjedes Artefakt 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.
© 2010 Altova GmbH
Deployment-Diagramme 53UModel Tutorial
Altova UModel 2010
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.
54 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2010 Altova GmbHAltova UModel 2010
4.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üfung die Generierung von Projektcode das Hinzufügen einer neuen Methode zu externem Code, d.h. zur Klasse
"SavingsAccount" Synchronisieren des neuen UModel Codes mit dem Modell
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" durchdie sechs Klassen, aus denen sie besteht, realisiert wird. Dies ist die Komponente, die erzeugtwird, nachdem wir den Abschnitt "Forward Engineering" in diesem Tutorial fertig gestellt haben.
Voraussetzungen für das Erzeugen von Code:
Die Komponente muss von einer oder mehreren Klassen realisiert werden. Der Komponente muss ein physischer Pfad, d.h. ein Verzeichnis zugewiesen sein.
Der generierte Code wird anschließend in diesem Verzeichnis abgelegt. Komponenten müssen einzeln so definiert werden, dass Sie in den Code
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 beimRound-Trip Engineering automatisch verarbeitet. Die Datei Bank_MultiLanguage.umpim 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 aufdie Schaltfläche zum Anlegen eines neuen Ordners, um einen neuen Ordneranzulegen. Der Pfad wird nun im Feld "directory" angezeigt.
© 2010 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 55UModel Tutorial
Altova UModel 2010
Bitte beachten Sie:Bei der Generierung von Java-Code hält sich UModel normalerweise an dieKonvention, Code in Verzeichnissen nach ihrem Namespace zu generieren, z.B....\code\namespace1\C1.java.
Wenn Sie diese Verzeichnisbenennungskonvention auch für C# und VB .NETverwenden möchten, wählen Sie die Menüoption Extras | Optionen | CodeEngineering und wählen Sie in der Gruppe Namespace für Codedateipfadverwenden die entsprechende Option aus.
So schließen Sie Komponenten in den Codegenerierungsvorgang ein oder nehmen diesedavon 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).
56 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2010 Altova GmbHAltova UModel 2010
Ü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.
© 2010 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 57UModel Tutorial
Altova UModel 2010
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ähere Informationen finden Sie unter Merge Programmcode von UMode-Projekt
58 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Round-Trip Engineering (Modell - Code - Modell) 59UModel Tutorial
Altova UModel 2010
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.
60 UModel Tutorial Round-Trip Engineering (Modell - Code - Modell)
© 2010 Altova GmbHAltova UModel 2010
6. Klicken Sie auf das Register Account Hierarchy, um das Ergebnis desMerge-Vorgangs zu sehen.
Die neu zum Code hinzugefügte Methode (getInterestRate...) generiert eine neue Operation in der Klasse "SavingsAccount" von UModel.
© 2010 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 61UModel Tutorial
Altova UModel 2010
4.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 wurde in UModel eine neue Klasse zum Projekt hinzuzufügen den Programmcode aus einem UModel Paket zu überführen
Die in diesem Beispiel verwendeten Dateien sind in der Datei OrgChart.zip im Ordner...\UmodelExamples Ihres Installationsverzeichnisses verfügbar. Entpacken Sie bitte die Datei"OrgChart.zip" in den Ordner ...\UmodelExamples, bevor Sie mit diesem Abschnitt beginnen.Dadurch wird das Verzeichnis "Orgchart" erstellt, das wir anschließend zum Importieren vonCode verwenden werden.
Reverse Engineering/Importieren von bestehendem Code aus einem Verzeichnis:1. Wählen Sie Datei | Neu um ein neues Projekt zu erstellen.2. Wählen Sie Projekt | Quellverzeichnis importieren.3. Wählen Sie die C#- (1.2, 2.0, 3.0 oder 4.0) oder Java-Version (1.4 oder 5.0) oder die
VB-Version (7.1., 8.0 oder 9.0) für den Quellcode aus.
4. Klicken Sie auf die Durchsuchen-Schaltfläche und wählen Sie das VerzeichnisOrgChart aus dem Ordner ...\UModelExamples.
5. Stellen Sie sicher, dass das Kontrollkästchen "Diagrammgenerierung aktivieren"aktiv ist, wählen Sie die gewünschten Importeinstellungen aus und klicken Sie auf"Weiter".
62 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2010 Altova GmbHAltova UModel 2010
Beachten Sie: In UModel können Sie sowohl ein einzelnes Übersichtsdiagrammerstellen als auch/oder Diagramme für die einzelnen Pakete. Die Einstellungen obensind die Standardeinstellungen.
6. Klicken Sie zum Fortfahren auf "Weiter".
In diesem Dialogfeld können Sie die Einstellungen für die Generierung vonPaketabhängigkeiten definieren.
7. Klicken Sie auf "Fertig stellen", um die Standardeinstellungen zu verwenden. Die Daten werden während der Eingabe geparst und ein neues Paket namens "OrgChart" wird erstellt.
© 2010 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 63UModel Tutorial
Altova UModel 2010
8. Erweitern Sie das neue Paket und dessen Unterpakete bis Sie zum Paket OrgChart (com | OrgChart) gelangen.
9. Doppelklicken Sie auf das Inhalt von OrgChart-Diagrammsymbol . Dieausgeblendeten Klassen, aus denen OrgChart besteht, werden auf dem Hauptregisterangezeigt. Welcher Ausschnitt im aktuellen Fenster/in der aktuellen Ansicht angezeigtwird, sehen Sie an dem roten Kästchen im Übersichtsfenster.
10. Klicken Sie auf den roten Rahmen und ziehen Sie ihn in die Mitte des Fenstersherunter.
64 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2010 Altova GmbHAltova UModel 2010
Bitte beachten Sie:Sie könnten auch die Option Projekt | Quellprojekt importieren wählen und dieBorland JBuilder Projektdatei OrgChart.jpx auswählen, um das von XMLSpygenerierte Projekt zu importieren.
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 werdenfür jene 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.
Hinzufügen einer neuen Klasse zum OrgChart-Diagramm:
1. Klicken Sie in der Symbolleiste auf das Symbol "Klasse" und klicken Sie, um eineneue Klasse einzufügen.
2. Fügen Sie eine neue Klasse mit dem Namen CompanyType hinzu.3. Fügen Sie mittels der Taste F8 neue Operationen zur Klasse hinzu:
Z.B. CompanyType(), getCompanyType():String, setCompanyType():String.
Verfügbarmachen der neuen Klasse für die Codegenerierung:Während die Klasse "CompanyType" aktiv ist,
© 2010 Altova GmbH
Round-Trip Engineering (Code - Modell - Code) 65UModel Tutorial
Altova UModel 2010
1. Klicken Sie in das Feld "Codedateiname" und geben Sie den Java-Dateinamen derneuen Klasse CompanyType.java ein.
2. Klicken Sie in der Modellstruktur auf die neue Klasse "CompanyType" und ziehen Siesie nach oben auf die OrgChart-Komponente unterhalb des Component View-Pakets.Es erscheint ein Popup, wenn der Mauszeiger sich über einer Komponente befindet.
Bitte beachten Sie:Mit dieser Methode wird eine Realisierung zwischen einer Klasse und einerKomponente erstellt, ohne dass Sie Komponenten- oder Deployment-Diagrammeverwenden müssen.
3. Erweitern Sie das Element Beziehungen unterhalb der Komponente "Orgchart" um die
66 UModel Tutorial Round-Trip Engineering (Code - Modell - Code)
© 2010 Altova GmbHAltova UModel 2010
neu erstellte Realisierung zu sehen.
Merge von Programmcode aus einem Paket1. Rechtsklicken Sie auf das Paket OrgChart, wählen Sie Code Engineering | Merge
Programmcode von UModel Paket und bestätigen Sie den Vorgang mit derEingabetaste.
Im Meldungsfenster wird die Syntaxüberprüfung angezeigt, die durchgeführt wird, undder Status des Synchronisierungsvorgangs.
Nach Abschluss des Vorgangs ist die neue Klasse CompanyType.java zum Ordner ...\OrgChart\com\OrgChart\ hinzugefügt.
Bitte beachten Sie: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.
Das war's auch schon!Sie wissen nun, wie man ein Modellierungsprojekt mit Hilfe von Forward Engineering erstelltund haben ein komplettes Round-Trip Engineering durchgeführt. Im restlichen Teil dieserDokumentation erfahren Sie, wie man die besten Ergebnisse beim Erstellen von Modellen mit UModel erzielt.
68 UModel Benutzeroberfläche
© 2010 Altova GmbHAltova UModel 2010
5 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önnenSie Ihr UModel-Projekt nach verschiedenen Aspekten anzeigen bzw. darin navigieren undDaten direkt editieren.
Die Fensterbereiche nennen sich: Modell-Struktur, Eigenschaften und Übersicht. DerArbeits-/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.
© 2010 Altova GmbH
Modell-Struktur 69UModel Benutzeroberfläche
Altova UModel 2010
5.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ügen kopieren oder verschieben löschen umbenennen nach verschiedenen Kriterien sortieren einschränken
Auf dem Register "Modell-Struktur" ist jeder Ordner ein UML-Paket!
Hinzufügen eines neuen Pakets (oder eines beliebigen anderen Modellierungselements):1. Rechtsklicken Sie auf den Ordner, unter dem das neue Paket/Element angezeigt
werden soll.2. Wählen Sie Neu | Paket (oder das jeweilige Modellelement).
Kopieren oder Verschieben von Modellelementen:1. Verwenden Sie die Windows-Standardbefehle "Ausschneiden", "Kopieren" oder
"Einfügen" oder 2. Ziehen Sie Modellelemente in andere Pakete. Durch Ziehen eines Elements
verschieben Sie es. Wenn Sie die Strg-Taste gedrückt halten, während Sie dasElement ziehen, wird eine 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ührenkönnen. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren undEinfügen in UModel Diagrammen.
70 UModel Benutzeroberfläche Modell-Struktur
© 2010 Altova GmbHAltova UModel 2010
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ähereInformationen dazu finden Sie unter Löschen von Elementen.
So öffnen Sie ein Diagramm auf dem Diagrammregister:
1. Doppelklicken Sie auf das Diagrammsymbol des Diagramms, das Sie auf 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 Paketdeklarationenerstellt)
Diagrammtypen:
Aktivitätsdiagramm Profildiagramm
Klassendiagramm Sequenzdiagramm
Kommunikationsdiagramm Zustandsdiagramm
Komponentendiagramm SysML-Diagramme (9Diagrammtypen)
Kompositionsstrukturdiagramm Zeitverlaufsdiagramm
Deployment-Diagramm Use Case-Diagramm
Interaktionsübersichtsdiagramm XML-Schema-Diagramm
Objektdiagramm Business Process ModelingNotation
PaketdiagrammElementtypen:
© 2010 Altova GmbH
Modell-Struktur 71UModel Benutzeroberfläche
Altova UModel 2010
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 öffnen Drücken Sie die +-Taste, um das aktuelle Paket zu öffnen.
Zum Reduzieren der Pakete drücken Sie die --Taste.Sie können dafür sowohl die Tasten der Standardtastatur als auch die desZahlenblocks verwenden.
So suchen Sie auf dem/den Diagrammregister(n) Modellierungselemente:Beim Navigieren durch die Elemente in der Modell-Struktur möchten Sie eventuell sehen, wooder ob 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
Diagrammregistertyp zu suchen Element in allen Diagrammen anzeigen - wenn das derzeit aktive Diagramm sich
vom ausgewählten Modellelement unterscheidet.
So generieren Sie eine Liste von Elementen, die in keinem Diagramm verwendet werden: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 Elementeangezeigt. Die in Klammer angezeigte Liste enthält die spezifischen Elemente, dieausgewählt wurden und in der Liste der nicht verwendeten Elemente aufscheinensollen. Nähere Informationen dazu finden Sie im Referenzabschnitt unter dem Register Ansicht unter Extras | Optionen.
72 UModel Benutzeroberfläche Modell-Struktur
© 2010 Altova GmbHAltova UModel 2010
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 dessenUnterpakete angezeigt.
Pakete auf dem Register "Modell-Struktur": Beim Start, d.h. wenn kein Projekt geladen ist, sind nur die Pakete "Root" und "ComponentView" zu sehen.
Pakete können an jeder Stelle in der Modell-Struktur erstellt oder gelöscht werden Pakete sind die Behälter für alle anderen UML-Modellierungselemente, Use
Case-Diagramme usw. Pakete/Inhalt können/kann in andere Pakete in der Modell-Struktur (und auch in gültige
Modell-Diagramme auf dem Diagrammregister) verschoben/kopiert werden Paketen und deren Inhalt können gemäß verschiedenen Kriterien sortiert werden Pakete können in andere Pakete platziert werden Pakete können beim Generieren oder Synchronisieren von Code als Quell- oder
Zielelemente verwendet werden
Generieren/Zusammenführen von Code:UModel gestattet Ihnen, Programmcode direkt von der Modell-Struktur aus zu generieren 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.
So schränken Sie ein Element in UML-Diagrammen ein:1. Doppelklicken Sie auf das jeweilige Element, um es editieren zu können.
© 2010 Altova GmbH
Modell-Struktur 73UModel Benutzeroberfläche
Altova UModel 2010
2. Geben Sie den Namen der Einschränkung innerhalb einer geschwungenen Klammerein 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, denenes zugewiesen wurde. In der obigen Abbildung wurde Constraint1 den Paketen bankview und com zugewiesen.
74 UModel Benutzeroberfläche Diagramm-Struktur
© 2010 Altova GmbHAltova UModel 2010
5.2 Diagramm-Struktur
Register "Diagramm-Struktur"Auf diesem Register werden die aktuell verfügbaren UModel-Diagramme auf zwei Artendargestellt:
Gruppiert nach Diagrammtyp, in alphabetischer Reihenfolge Als 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".
© 2010 Altova GmbH
Diagramm-Struktur 75UModel Benutzeroberfläche
Altova UModel 2010
Alle Diagramme werden in Form einer alphabetisch sortierten Liste angezeigt.
76 UModel Benutzeroberfläche Favoriten
© 2010 Altova GmbHAltova UModel 2010
5.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 Ihrepersönliche Liste von Modellierungselementen erstellen, die zur schnellen Auswahl zurVerfü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 sinddaher auch auf dem Register "Modell-Struktur" zu sehen.
So ENTFERNEN Sie ein Element vom Register "Favoriten":1. Rechtsklicken Sie auf dasselbe Element/Paket, das Sie zu Favoriten hinzugefügt
haben. 2. Wählen Sie die Option Aus Favoriten entfernen.
Bitte beachten Sie:Sie können Elemente, die Sie zum Register "Favoriten" hinzugefügt haben, sowohl überdas Register "Favoriten" als auch über das Register "Modell-Struktur" hinzufügen undentfernen.
© 2010 Altova GmbH
Favoriten 77UModel Benutzeroberfläche
Altova UModel 2010
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
© 2010 Altova GmbHAltova UModel 2010
5.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. Klicken Sie auf das Popup "In Modell-Struktur auswählen".
Die IBankAPI-Schnittstelle wird nun in der Modell-Struktur angezeigt.
80 UModel Benutzeroberfläche Stile
© 2010 Altova GmbHAltova UModel 2010
5.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 Klickenauf das Listenfeld "Stile" auswählen können. Der Inhalt des Listenfelds ist vom aktuellausgewählten Modellelement abhängig.
Durch Klicken auf ein Element auf einem Diagrammregister wird automatisch der Kontext"Elementstile" ausgewählt. Bei Klicken auf ein Element auf dem Register "Modell-Struktur" 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 Objektemit Ausnahme des soeben auf der Ebene Elementstile geänderten Objekts aktualisiert.
Bitte beachten Sie:Alle an Modellelementen vorgenommenen Stiländerungen können rückgängig gemachtwerden!
© 2010 Altova GmbH
Stile 81UModel Benutzeroberfläche
Altova UModel 2010
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 Stereotypklsse 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 Siealle Komponentenelemente in der Farbe "Aqua" anzeigen lassen. Daraufhin werden alleKomponenten in Komponenten- und Deployment-Diagrammen in Aqua angezeigt.
Knotenstile/Linienarten: "Knoten" gilt für alle rechteckigen Objekte."Linien" gilt für alle Konnektoren: Assoziations-, Abhängigkeits-, Realisierungslinien usw. für 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 NewRoman" ändern möchten.
Diagrammstile:Diese Stile stehen nur zur Verfügung, wenn Sie auf einen Diagrammhintergrund klicken bzw.ihn auswählen. Wenn Sie Einstellungen hier ändern, wird davon nur das einzelneUML-Diagramm, für das die Einstellungen im Projekt definiert sind, betroffen.
So ändern Sie die Einstellungen für alle Diagramme eines Projekts:1. Klicken Sie in das jeweilige Diagramm, 2. Wählen Sie im Listenfeld den Eintrag Projektstile und scrollen Sie zum unteren Rand
des Registers. 3. Wählen Sie eine der Diag.yyy-Optionen z.B. Diag.Hintergrundfarbe.
Daraufhin wird die Hintergrundfarbe aller Diagramme im aktuellen Projekt geändert.
Anzeige von Stilen bei Auswahl mehrerer Elemente:Wenn im Diagrammfenster mehrere Elemente ausgewählt sind, werden alle 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.
Anzeige von einander überlappenden Stilen: Wenn ein Stil durch einen Stil auf einer untergeordneten Ebene außer Kraft gesetzt wird, wirdauf dem Register "Stile" im entsprechenden Feld ein kleines rotes Dreieck angezeigt.Wenn Sie den Mauszeiger über das Feld platzieren, wird ein Popup-Fenster angezeigt, in dem
82 UModel Benutzeroberfläche Stile
© 2010 Altova GmbHAltova UModel 2010
angegeben wird, welcher Stil Vorrang hat.
Beispiel:Für die Elemente "Enumeration", "Paket" und "Profil" sind in denElementfamilienstileinstellungen Standardfüllfarben definiert. Um die Füllfarben aufProjektebene zu ändern, löschen Sie den Wert unter "Elementfamilie - Stile", indem Sie imDropdown-Listenfeld den leeren Eintrag auswählen, wählen Sie in der Auswahlliste "Stile" denEintrag "Projektstile" aus und ändern Sie dort die Füllfarbe.
© 2010 Altova GmbH
Hierarchie 83UModel Benutzeroberfläche
Altova UModel 2010
5.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.
Strukuransicht 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 diejeweiligen Schaltflächen durch Anklicken aktivieren. In der Abbildung oben sind alleSchaltfläche aktiv, daher werden 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
© 2010 Altova GmbHAltova UModel 2010
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.
1. Rechtsklicken Sie in das Fenster "Graph. Ansicht" und wählen Sie den Befehl
© 2010 Altova GmbH
Hierarchie 85UModel Benutzeroberfläche
Altova UModel 2010
Diagramm als diesen Graph erstellen.
2. Bearbeiten Sie den Namen des Diagramms gegebenenfalls, wählen Sie dieStiloptionen aus und klicken Sie auf OK.Ein neues Diagramm wird erstellt.
86 UModel Benutzeroberfläche Übersicht - Dokumentation
© 2010 Altova GmbHAltova UModel 2010
5.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 sichder angezeigte Bereich auf dem Diagrammregister.
© 2010 Altova GmbH
Dokumentation 87UModel Benutzeroberfläche
Altova UModel 2010
5.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 aufdem Register "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 Inputbzw. Output verwendet. Dazu gehört auch Dokumentation, die fürKlassen-/Schnittstelleneigenschaften und -operationen definiert wurde.
1. Wählen Sie Projekt | Synchronisierungseinstellungen.2. Aktivieren Sie das Kontrollkästchen "Dokumentation als JavaDocs schreiben" um
die Ausgabe von Dokumentation zu aktivieren.
Bitte beachten Sie:Beim Import von XML-Schemas wird nur die erste Annotation eines complex- oder simpleTypeim Fenster "Dokumentation" angezeigt.
88 UModel Benutzeroberfläche Meldungen
© 2010 Altova GmbHAltova UModel 2010
5.9 Meldungen
Im Fenster "Meldungen" werden beim Zusammenführen von Code oder beim Überprüfen derProjektsyntax Meldungen, Hinweise und Fehlermeldungen angezeigt.
© 2010 Altova GmbH
Diagrammfenster 89UModel Benutzeroberfläche
Altova UModel 2010
5.10 Diagrammfenster
Alle aktuell geöffneten UModel-Diagramme werden im Diagrammfenster auf einzelnenRegistern angezeigt.
So erstellen Sie ein neues Diagramm: 1. Klicken Sie auf dem Register "Modell-Struktur" auf ein Paket.2. Wählen Sie Neu | YYY Diagramm.
So erstellen Sie ein neues Diagramm, das den Inhalt eines bestehenden Pakets enthält:1. Rechtsklicken Sie auf ein Paket und wählen Sie In neuem Diagramm anzeigen |
Inhalt.
So öffnen Sie ein Diagramm bzw. rufen es auf:
Doppelklicken Sie auf das Diagrammsymbol auf einem der Register derModell-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 dieEntf-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.
Suchen (Löschen) von Klasseneigenschaften und Optionen aus der Modell-Struktur:Eigenschaften und Optionen können auch direkt aus der Modell-Struktur gelöscht werden.Dazu müssen Sie zuerst die richtige Eigenschaft finden. Angenommen, Sie haben "Operation1"
90 UModel Benutzeroberfläche Diagrammfenster
© 2010 Altova GmbHAltova UModel 2010
in die Klasse "Account" eingefügt (drücken Sie zum Einfügen F8 und anschließend dieEingabetaste):
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 beneihe jedes Modellierungselement inder Modell-Struktur finden können.
Bitte beachten Sie: Sie können beim Anzeigen von Attributeigenschaften auch vom Fenster"Eigenschaften" zur Modell-Struktur navigieren. Nähere Informationen dazu finden Siein der Benutzerreferenz unter Eigenschaften.
Löschen von Elementen aus einem Diagramm:
Löschen von Elementen aus dem Diagramm und dem Projekt! Wählen Sie das zu löschende Element aus und drücken Sie die Entf-Taste.
Löschen von Elementen nur aus dem Diagramm - nicht aus dem Projekt!1. Wählen Sie das zu löschende Element 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 oder Automatisches Layout | Hierarchisch Automatisches Layout | Block
Anzeigen von Beziehungen zwischen Modellelementen:1. Rechtsklicken Sie auf das entsprechende Element und wählen Sie den Befehl
Anzeigen.
© 2010 Altova GmbH
Diagrammfenster 91UModel Benutzeroberfläche
Altova UModel 2010
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.
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.
92 UModel Benutzeroberfläche Diagrammfenster
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Diagrammfenster 93UModel Benutzeroberfläche
Altova UModel 2010
5.10.1 Diagrammeigenschaften
Konfigurieren von DiagrammeigenschaftenKlicken Sie auf den Diagrammhintergrund und wählen Sie anschließend einen der Stile ausdem Listenfeld "Styles" aus. Nähere Informationen finden Sie unter Fensterbereich "Stile".
So vergrößern Sie ein Diagramm:Die Größe des Diagrammregisters hängt von den Elementen und ihrer Platzierung ab.
Ziehen Sie ein Element zu einem der Ränder des Diagrammregisters, um automatischdurch das Register zu scrollen und es zu vergrößern.
Positionieren von Modellierungselementen - das RasterModellierungselemente können manuell positioniert werden oder an einemsichtbaren/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, alsVorlage das zuletzt ausgewählte Element verwendet. Wenn Sie z.B. drei Klassenelementeauswählen und auf die Schaltfläche "Breite angleichen" klicken, dann werden alle drei Elementein der Breite an die zuletzt ausgewählte Klasse angepasst.
Das gleiche gilt auch bei Markierung mehrerer Objekte mit der Marquee-Technik (Aufzieheneines Rechtecks). Hier dient das zuletzt ausgewählte Element als Vorlage für die anderenmarkierten Objekte
Schaltflächenfunktionen für die einzelnen Schaltflächengruppen:Linksbündig, RechtsbündigBündig oben, Bündig unten
94 UModel Benutzeroberfläche Diagrammfenster
© 2010 Altova GmbHAltova UModel 2010
Vertikal 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 entsprechende
Kategoriesymbol 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 Aktivierungmehrerer Kategoriesymbole (Mehrfachmodus). In der Abbildung unten sehen Sie dasAutokomplettierungsfenster im Mehrfachmodus, d.h. alle Kategoriesymbole sindaktiviert. Das Einzelmodussymbol ist deaktiviert.
Mit den Schaltflächen "Alle setzenl / Zurücksetzen" können Sie alleKategorieeinstellungen setzen bzw. zurücksetzen.
Autokomplettierungs-Popup-Fenster, das mit Strg+ Leerzeichen aufgerufen werdenkann, wenn die Autokomplettierung deaktiviert ist.
´
Filterkategorien:Klasse, Schnittstelle, Primitivtyp, Datentyp, Enumeration, Klassenvorlage,Schnittstellen-Vorlage, Datentyp-Vorlage.
Bitte beachten Sie:Um die Autokomplettierung zu aktivieren/zu deaktivieren, wählen Sie Extras |Optionen | Diagrambearbeitung (Register) und aktivieren Sie die Option"Automatische Eingabehilfe aktivieren". Diese Einstellung hat keinen Einfluss auf dieFunktion zum Aufrufen des Autokomplettierungsfensters.
© 2010 Altova GmbH
Diagrammfenster 95UModel Benutzeroberfläche
Altova UModel 2010
5.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 verschiedeneArten:
Nachdem Sie ein Element kopiert haben, gibt es folgende Möglichkeiten: Sie können es "einfügen". Dies erfolgt mit Hilfe der Tastaturkürzel Strg+V, mit dem
Kontextmenübefehl "Einfügen" oder über den Befehl "Einfügen" aus dem Menü"Bearbeiten". Dabei wird immer ein neues Modellelement zum Diagramm und 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 eine
neue 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 Klassekopiert.
Durch Einfügen einer kopierten Klasse in ein anderes Paket wird ebenfalls eine neueKlasse eingefügt, doch wird der ursprüngliche Klassenname beibehalten. In beidenFällen wird die neue Klasse auch zur Modell-Struktur hinzugefügt.
Einfügen (Strg+V) kopierter Eigenschaften oder Operationen: Durch Einfügen einer Eigenschaft in dieselbe Klasse wird eine neue Eigenschaft mit
dem Namen der Quelleigenschaft sowie einer Sequenznummer eingefügt, also z.B.MyProperty1.
Durch Einfügen einer Operation in dieselbe Klasse wird eine neue Operation mitdemselben Namen der Quelloperation eingefügt.
96 UModel Benutzeroberfläche Diagrammfenster
© 2010 Altova GmbHAltova UModel 2010
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/Eigenschaften
vorgenommen. Wenn Sie die Eigenschaften des Elements in einer der "Ansichten" ändern, werden
diese auch in der anderen automatisch geändert.
Kopieren und Einfügen von Elementen mit der Maus:1. Klicken Sie auf das gewünschte Modellelement.2. Verschieben Sie den Mauszeiger an die Stelle, an die Sie das neue Element platzieren
möchten.3. Halten Sie die Strg-Taste gedrückt. Unterhalb des Mauszeigers wird ein keines
Pluszeichen angezeigt, welches anzeigt, dass es sich hier um einen Kopiervorganghandelt.
4. Lassen Sie die Maustaste los.
© 2010 Altova GmbH
Diagrammfenster 97UModel Benutzeroberfläche
Altova UModel 2010
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 Operationendirekt innerhalb einer Klasse kopieren oder verschieben.
98 UModel Benutzeroberfläche Hinzufügen/Einfügen von Modellelementen
© 2010 Altova GmbHAltova UModel 2010
5.11 Hinzufügen/Einfügen von Modellelementen
Es gibt mehrere Methoden, um Modellelemente zu erstellen und in Diagramme einzufügen:
Durch Hinzufügen der Elemente zu bestimmten Paketen in der Modell-Strukturansicht Durch Ziehen von bestehenden Elementen vom Register "Modell-Struktur" auf das
Diagrammregister Durch Klicken auf ein bestimmtes UML-Elementsymbol und Einfügen in das Diagramm Durch Verwenden das Kontextmenüs, um Elemente zum Diagramm (und automatisch
zur Modell-Strukturansicht) hinzuzufügen.
Bitte beachten Sie, dass mehrere Elemente in der Modell-Strukturansicht entwederdurch Umschalt + Klick oder durch Strg + Klick ausgewählt werden können.
Hinzufügen von Elementen auf dem Register "Modell-Struktur"/"Favoriten":
Rechtsklicken Sie auf ein Paket, wählen Sie "Neu" und anschließend aus dem Menü,das erscheint, das jeweilige Element.Daraufhin wird das neue Element im aktuellen Projekt zum Register "Modell-Struktur"hinzugefügt.
Einfügen von Elementen aus der Modell-Strukturansicht in ein Diagramm:Modellelemente können einzeln eingefügt werden oder als Gruppe. Um mehrere Elemente 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:links ziehen und rechts ziehen.
Links ziehen (normales Drop and Drop): Fügt Elemente direkt an der Cursorpositionein (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.
© 2010 Altova GmbH
Hinzufügen/Einfügen von Modellelementen 99UModel Benutzeroberfläche
Altova UModel 2010
Beispiel:Sie möchten das Diagramm "Account Hierarchy" in einem neuen Klassendiagramm replizieren.
1. Rechtsklicken Sie auf das bankview-Paket und wählen Sie Neu | Klassendiagramm.2. Suchen Sie in der Modell-Struktur die abstrakte Klasse Account und verwenden Sie
den "Rechts ziehen"-Vorgang, um sie im neuen Diagramm zu platzieren.Daraufhin wird das oben gezeigte Kontextmenü geöffnet.
3. Wählen Sie den Eintrag Einfügen mit Generalisierungshierarchie (spezifisch).
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 der Symbolleiste:1. Wählen Sie das jeweilige Element, das Sie einfügen möchten aus, indem Sie in der
100 UModel Benutzeroberfläche Hinzufügen/Einfügen von Modellelementen
© 2010 Altova GmbHAltova UModel 2010
Symbolleiste auf das dazugehörige Symbol klicken.2. Klicken Sie auf das Diagrammregister, um das Element einzufügen.
Bitte beachten Sie:Wenn Sie vor dem Klicken auf das Diagrammregister die Strg-Taste gedrückt halten,können Sie mit den einzelnen Klicks in das Diagramm mehrere Elemente 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.
© 2010 Altova GmbH
Verknüpfen von Modellierungselementen 101UModel Benutzeroberfläche
Altova UModel 2010
5.12 Verknüpfen von Modellierungselementen
UModel unterstützt nun das automatische und manuelle Verknüpfen vonModellierungselementen mittels Hyperlink. Die Hyperlinks werden automatisch erstellt, wennSie beim Importieren von Quellcode oder Binärdateien in ein Modell die entsprechende Optionauswählen.
Die Erstellung von manuellen Hyperlinks wird zwischen den meisten Modellierungselementen(ausgenommen Linien) und:
jedem Diagram im aktuellen ump-Projekt jedem Element in einem Diagramm jedem Element in der Modellstruktur externen Dokumenten, z.B. PDF-, Excel- oder Word-Dokumenten Webseiten
unterstützt.
Anmerkung:Alle manuell erstellten Hyperlinks stehen bei Generierung von UML-Dokumentationauch in der HTML-Projektdokumentation zur Verfügung.
Wenn Sie das Bank Server-Diagramm unter dem Paket "Bank Server" öffnen, wird dieIBankAPI-Schnittstelle sowie die BankServer-Klasse angezeigt. Auch einEnumerationselement, das die Namen der EnumerationLiterals enthält, ist zu sehen. Wirmöchten nun einen Hyperlink von Enumeration zu Account Hierarchy-Klassendiagrammerstellen.
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.
102 UModel Benutzeroberfläche Verknüpfen von Modellierungselementen
© 2010 Altova GmbHAltova UModel 2010
Daraufhin wird das Dialogfeld "Hyperlinks bearbeiten" geöffnet. Hier werden dieHyperlinks verwaltet.
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.
© 2010 Altova GmbH
Verknüpfen von Modellierungselementen 103UModel Benutzeroberfläche
Altova UModel 2010
4. Klicken Sie auf OK, sobald Sie alle Ihre Hyperlinks definiert haben.Links oben wurde nun ein Link-Symbol zum Enumeration-Element hinzugefügt. WennSie den Mauscursor über das Linl-Symbol platzieren, erscheint ein Popup mit demNamen des Target-Elements.
Hyperlinks in Operationen
Hyperlinks von einer Eintrittsaktion in einem Zustandsdiagramm
So erstellen Sie einen Link zu einem bestimmten Diagrammelement (Diagrammlink):1. Erstellen Sie den Hyperlink, wie zuvor beschrieben, klicken Sie jedoch auf das +-
Zeichen, um den Inhalt des Diagramms erweitert anzuzeigen.
104 UModel Benutzeroberfläche Verknüpfen von Modellierungselementen
© 2010 Altova GmbHAltova UModel 2010
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, wobeidas Element sichtbar und ausgewählt ist.
So erstellen Sie einen Link zu einem Element in der Modell-Struktur (Modell-Link):
Gehen Sie vor, wie oben beschrieben. Klicken Sie aber im Dialogfeld auf den Befehl hinzufügen | Modell-Link.Wenn Sie auf den Link klicken, sobald er eingefügt wurde, werden Sie zum demElement gefü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ählen 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.
© 2010 Altova GmbH
Verknüpfen von Modellierungselementen 105UModel Benutzeroberfläche
Altova UModel 2010
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. sofortangezeigt.
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.
106 UModel Benutzeroberfläche Bank-Beispieldateien
© 2010 Altova GmbHAltova UModel 2010
5.13 Bank-Beispieldateien
Der Ordner ...\UModelExamples enthält Dateien mit Beispielen zu verschiedenen Aspektender UML-Modellierung in UModel. Sie sind so ausgelegt, dass Modelle für dieProgrammiersprachen Java und C# sowie eine Kombination beider Sprachen in einemModellierungsprojekt zu sehen sind.
In der Abbildung unten sehen Sie die Datei Bank_Java.ump: das Java-Profil wurde dem Paket "Bankview" zugewiesen die Java-Namespace Root wurde den Paketen "Banking access" und "BankView"
zugewiesen. das Paket "Interaction View" enthält zwei Interaction-Elemente, von denen jedes ein
Sequenzdiagramm enthält.
In der Abbildung unten sehen Sie die Datei Bank_CSharp.ump: das C#-Profil wurde dem Paket BankView zugewiesen die C# Namespace Root wurde den Paketen "Banking access" und "BankView"
zugewiesen. das Paket "Interaction View" enthält zwei Interaction-Elemente, von denen jedes ein
Sequenzdiagramm enthält.
© 2010 Altova GmbH
Bank-Beispieldateien 107UModel Benutzeroberfläche
Altova UModel 2010
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 ein
Sequenzdiagramm enthält.
110 UModel Befehlszeilenschnittstelle
© 2010 Altova GmbHAltova UModel 2010
6 UModel Befehlszeilenschnittstelle
UModel unterstützt nun auch die Batch-Verarbeitung. Die Datei "UModelBatch.exe" ist imOrdner ...\UModel2010 verfügbar.
Die Befehlszeilenparametersyntax wird unten gezeigt und kann im Fenster zur Befehlseingabeangezeigt werden, wenn Sie eingeben: umodelbatch /?
Bitte beachten Sie:Wenn der Pfad oder Dateiname ein Leerzeichen enthält, setzen Sie denPfad/Dateinamen bitte in Anführungszeichen, d.h. "c:\ProgramFiles\...\Dateiname"
usage: umodelbatch [project] [options]
/? oder /help ... diese Hilfeinformationen anzeigen
Projekt ... Projektdatei (*.ump)/new[=Datei] ... neues Projekt erstellen/speichern/unter einem neuen Namenspeichern, siehe auch Datei: New/Load/Save-Optionen/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
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 |VB7.1 | VB8.0 |VB9.0)/ipsd[=0|1] ... Unterverzeichnisse verarbeiten (rekursiv)/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
© 2010 Altova GmbH
111UModel Befehlszeilenschnittstelle
Altova UModel 2010
/iflt[=lst] ... Verzeichnisfilter (Voreinstellungen /iudf)/irpf[=0|1] ... relativ zur UModel-Projektdatei importieren
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] ... Attributbereiche anzeigen/dsoc[=0|1] ... Operation-Bereiche anzeigen/dscc[=0|1] ... Bereiche für geschachtelte Classifier anzeigen/dstv[=0|1] ... Eigenschaftswerte anzeigen
Optionen für Export-Befehle:/ejdc[=0|1] ... Java-Kommentare als JavaDocs/ecdc[=0|1] ... C#-Kommentare als DocComments/evdc[=0|1] ... VB-Kommentare als DocComments/espl[=0|1] ... benutzerdefinierte SPL-Vorlagen verwenden/ecod[=0|1] ... gelöschte auskommentieren/emrg[=0|1] ... zusammengeführte synchronisieren/egfn[=0|1] ... fehlende Dateinamen generieren/eusc[=0|1] ... Syntaxüberprüfung verwenden
Optionen für den XMI-Export/exex[=0|1] ... export UModel specific extensions/exdg[=0|1] ... export diagrams (presets /exex)/exuv[=ver] ... UML version (UML2.0 | UML2.1.2 | UML2.2 | UML2.3)
Optionen für die Dokumentationsgenerierung/doof[=fmt] ... Format ausgeben (HTML | RTF | MSWORD )
Im Abschnitt "Projekt":
Der Parameter /new definiert den Pfad und Namen der neuen Projektdatei (*.ump). Sie könnendiesen Parameter auch verwenden, um ein bestehendes Projekt unter einem anderen Namenzu speichern, z.B. UmodelBatch.exe MyFile.ump /new=MyBackupFile.ump. Siehe auchDatei: New/Load/Save-Optionen
Der Parameter /set überschreibt die aktuellen Standardeinstellungen in der Registrierungsdatei,wobei die Optionen/Einstellungen hier definiert werden.
Der Parameter /gui zeigt die UModel-Benutzeroberfläche bei der Batchverarbeitung an.
Beispiel 1:Importiert Quellcode und erstellt eine neue Projektdatei:
112 UModel Befehlszeilenschnittstelle
© 2010 Altova GmbHAltova UModel 2010
"C:\Program Files\Altova\UModel2010\UModelBatch.exe" /new="C:\ProgramFiles\Altova\UModel2010\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" erhaltenund unter C:\Program Files\Altova\UM odel2010 \UModelBatchOut\ erstelltwerden soll
/isd= Gibt an, das das Root-Verzeichnis, in das importiert werden soll"X:\TestCases\UModel\Fred" sein soll.
/set: Gibt an, dass alle in der Befehlszeile verwendeten Optionen in 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: erstellt für jedes importierte Verzeichnis im UModel-Projekt Pakete
/ijdc=1: erstellt gegebenenfalls JavaDoc anhand von Kommentaren
/dgen=1: generiert Diagramme
/dopn=1: öffnet generierte Diagramme
/dmax=5: öffnet maximal 5 Diagramme
/chk: führt eine Syntaxüberprüfung durch
Beispiel 2:Importiert Quellcode aus X:\TestCases\UModel und speichert die erzeugte Projektdatei unter"C:\Program...".
"C:\Program Files\Altova\UModel2010\UModelBatch.exe" /new="C:\ProgramFiles\Altova\UModel2010\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: unterdrückt Attribute in den generierten Diagrammen/dsnc=1: unterdrückt geschachtelte Classifier in den generierten Diagrammen
Beispiel 3:Synchronisiert Code mit einer vorhandenen Projektdatei (z.B. einer der oben erstellten).
"C:\Program Files\Altova\UModel2010\UModelBatch.exe" "C:\Program Files\Altova\UModel2010\UModelBatchOut\Fred.ump" /m2c /ejdc=1 /ecod=1 /emrg=1 /egfn=1/eusc=1
"C:\Program Files\Altova\UModel2010\UModelBatchOut\Fred.ump": die Projektdatei, die wirverwenden möchten.
/m2c Code anhand von Modell aktualisieren
/ejdc: Kommentare im Projektmodell sollen als JavaDoc generiert werden
© 2010 Altova GmbH
113UModel Befehlszeilenschnittstelle
Altova UModel 2010
/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
© 2010 Altova GmbHAltova UModel 2010
6.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 alsyyy.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 GUIbleibt offen
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
Wenn bei Ausführung der anderen Optionen schwere Fehler auftreten, wird in alleFällen nichts gespeichert!
116 Projekte und Code Engineering
© 2010 Altova GmbHAltova UModel 2010
7 Projekte und Code Engineering
Alle Java-spezifischen Konstrukte werden nun in UModel unterstützt, unter anderem:
Java Annotationen Attribute, Operationen und geschachtelte Qualifier für EnumerationLiterals Enumerationen können Schnittstellen realisieren Netbeans Projektdateien
Reverse Engineering unterstützt jetzt:
die Möglichkeit ein einziges Diagramm für alle mit Reverse Engineering generiertenElemente zu erzeugen.
die Möglichkeit, anonyme gebunde Elemente in Diagrammen ein- und auszublenden die Möglichkeit, während des Imports automatisch Hyperlinks von Paketen zu den
entsprechenden Paket-Inhaltsdiagrammen anzulegen. die Möglichkeit Aliasse aufzulösen. das Schreiben von Unicode-Zeichen in neue Quellcodedateien
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 erstelltwird, und auf dem Register "Modell-Struktur" angezeigt. Es wird ein neues Projekt mit demStandardnamen NeuesProjekt1 erstellt. Beachten Sie, dass beim Start von UModelautomatisch ein neues Projekt geöffnet wird.
Ein neu erstelltes UModel-Projekt besteht aus den folgenden Paketen:
Root-Paket und Component View-Paket
Diese beiden Pakete sind die einzigen, die nicht umbenannt oder gelöscht werdenkönnen.
Alle projektrelevanten Daten werden in der UModel-Projektdatei gespeichert. Diese Datei hatdie Erweiterung *.ump. Jedes Ordnersymbol auf dem Register "Modell-Struktur" stellt einUML-Paket dar!
© 2010 Altova GmbH
117Projekte und Code Engineering
Altova UModel 2010
UModel-Projektarbeitsablauf:UModel zwingt Sie nicht, sich bei der Modellierung an eine bestimmte vordefinierte Reihenfolgezu halten!
Sie können jeden Modellelementtyp zum Projekt hinzufügen: UML-Diagramm, Paket, Akteurusw. - und zwar in jeder beliebigen Reihenfolge bzw. and jeder beliebigen Stelle; Beachten Sie,dass alle Modellelemente direkt auf dem Register "Modell-Struktur" eingefügt, umbenannt undgelöscht werden können, d.h. Sie müssen diese Elemente nicht unbedingt als Teil einesDiagramms erstellen.
So fügen Sie ein neues Paket ein:1. Rechtsklicken Sie auf das Paket, unter dem das neue Paket angezeigt werden soll,
also in einem neuen Projekt entweder "Root" oder "Component View".2. Wählen Sie Neu | Paket.
Unterhalb des bestehenden Pakets wird ein neues Paket erstellt. Das Namensfeld wirdautomatisch markiert, sodass Sie sofort den Paketnamen eingeben können.
Pakete sind die Behälter für alle anderen UML-Modellierungselemente, UseCase-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ültige
Modell-Diagramme auf dem Diagrammregister) verschoben/kopiert werden. Pakete und deren Inhalt können (auf dem Register "Modell-Struktur") nach
verschiedenen Kriterien sortiert werden. Pakete können innerhalb von anderen Paketen platziert werden. Pakete können beim Zusammenführen oder Synchronisieren von Code als Quell- oder
Zielelemente verwendet werden.
Damit Elemente in einem UML-Diagramm angezeigt werden, müssen Sie:1. ein neues UML-Diagramm einfügen. Rechtsklicken Sie dazu und wählen Sie Neu |
(Klassen)diagramm.2. ein bestehendes Modellelement aus der Modell-Struktur in ein neu erstelltes Diagramm
ziehen 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.Sie können auswählen, ob das Projekt neu geladen werden soll oder nicht.
So verschieben Sie ein Projekt:UModel-Projekte und generierter Code können ganz einfach in ein anderes Verzeichnis (oderauf einen anderen Computer) verschoben und dort erneut synchronisiert werden.
Dazu gibt es zwei Methoden:
Wählen Sie die Menüoption Datei | Speichern unter... und klicken Sie auf Ja, wennSie gefragt werden, ob die Dateipfade an den neuen Projektordner angepasst werden
118 Projekte und Code Engineering
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Mini-UModel Projekt - von Grund auf neu erstellen 119Projekte und Code Engineering
Altova UModel 2010
7.1 Mini-UModel Projekt - von Grund auf neu erstellen
In diesem Abschnitt werden die Schritte beschrieben, die nötig sind, um ein Projekt von Grundauf neu zu erstellen und Code für eine einzige Klasse zu generieren. Hier wird anhand einesMini-Projekts jedoch unter Verwendung mehrerer Diagramme gezeigt, wie man Methodenhinzufügt usw. Alle diese Aktionen könnten auch nur unter Verwendung des Registers "Modell-Struktur" durchgeführt werden. Zur Erstellung von Klassen oder Methoden werden 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 |
Klassendiagramm.2. Rechtsklicken Sie in das Klassendiagramm und wählen Sie Neu | Klasse, um im
Diagramm eine neue Klasse zu erstellen z.B. MyClass.
120 Projekte und Code Engineering Mini-UModel Projekt - von Grund auf neu erstellen
© 2010 Altova GmbHAltova UModel 2010
3. Drücken Sie F7 und fügen Sie einige Attribute hinzu, z.B. UserName:String undPassword:String.
4. Drücken Sie F8 und fügen Sie einige Optionen hinzu, z.B. GetUserName:String undGetPassword: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.
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.
© 2010 Altova GmbH
Mini-UModel Projekt - von Grund auf neu erstellen 121Projekte und Code Engineering
Altova UModel 2010
Realisieren der Klasse1. Klicken Sie auf MyFirstClass und ziehen Sie den Ziehpunkt "
Komponentenrealisierung" am unteren Rand des Elements auf die neueKomponente MyComponent.
Eine Klasse muss "realisiert" werden, bevor Code generiert werden kann. BeachtenSie, 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 in Ordnung ist.
122 Projekte und Code Engineering Mini-UModel Projekt - von Grund auf neu erstellen
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Importieren von Quellcode in Projekte 123Projekte und Code Engineering
Altova UModel 2010
7.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) werden derzeitunterstützt..
C#-Projekte / Visual Basic-Projekte:- MS Visual Studio.NET-Projekte, sln, csproj, csdprj..., vbproj, vbp sowie - Borland .bdsproj Projektdateien
So importieren Sie bestehenden Code in UModel:1. Wählen Sie Projekt | Quellprojekt importieren.
2. Klicken Sie auf das Durchsuchen-Symbol im Dialogfeld "Quellprojekt importieren".
3. Wählen Sie den Projektdateityp aus, z.B. .jpx und klicken Sie zum Bestätigen auf"Öffnen". Sie finden die Jbuilder-Projektdatei in der Datei OrgChart.zip im Ordner...\UModelExamples. Beachten Sie, dass die Option zum Importieren des Projektsrelativ zur UModel-Projektdatei aktiv ist.
124 Projekte und Code Engineering Importieren von Quellcode in Projekte
© 2010 Altova GmbHAltova UModel 2010
4. Stellen Sie sicher, dass das Kontrollkästchen "Diagrammgenerierung aktivieren"aktiv ist und aktivieren Sie alle anderen benötigten Importeinstellungen. Klicken Sieanschließend auf "Weiter".
5. Aktivieren Sie das Kontrollkästchen "In neues Paket importieren" (oder klicken Sie imFester "Importziel" auf das entsprechende Paket).
Beachten Sie: Sie können in UModel ein einziges Übersichtsdiagramm und/oder einDiagramm für jedes einzelne Paket erstellen. Die gezeigten Einstellungen sind dieStandardeinstellungen.
© 2010 Altova GmbH
Importieren von Quellcode in Projekte 125Projekte und Code Engineering
Altova UModel 2010
6. Klicken Sie zum Fortfahren auf "Weiter".In diesem Dialogfeld können Sie die Einstellungen für die Generierung vonPaketabhängigkeiten definieren.
7. Klicken Sie auf "Fertig stellen", um die Standardeinstellungen zu verwenden.
Das Projekt wird geparst und das UModel-Modell wird generiert.
126 Projekte und Code Engineering Importieren von Quellcode in Projekte
© 2010 Altova GmbHAltova UModel 2010
Bitte beachten Sie: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önnenSie nun 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, werdenAlias-Definitionen im Code unverändert beibehalten. Der Geltungsbereich der Aliasdefinitionensind die Dateien, in denen diese vorkommen.
z.B. using Q = System.Collections.Generic.Queue<String>;Q myQueue;
Alle Aliasse, bei denen es zu einem Konflikt kommen könnte, werden zu den "unbekanntenexternen Elementen" hinzugefügt, wenn ihre Verwendung nicht eindeutig ist.
Anmerkung:Die Einstellung "Aliasnamen auflösen" kann jederzeit im Dialogfeld "Projekteinstellungen"geändert werden.
© 2010 Altova GmbH
Importieren von Quellcode in Projekte 127Projekte und Code Engineering
Altova UModel 2010
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.
128 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2010 Altova GmbHAltova UModel 2010
7.3 Importieren von Java-, C#- und VB-Binärdateien
UModel unterstützt nun auch den Import von C#-, Java- und VB-Binärdateien. Diese Funktionerweist sich vor allem beim Arbeiten mit Binärdateien aus externen Quellen oder, wenn derQuellcode nicht mehr zur Verfügung steht, als besonders nützlich.
Um Java- und/oder C#-Binärdateien zu importieren, müssen die folgenden Programme/Komponenten installiert werden.
Java 1.4 / 5.0:Sun Java Runtime Environment (JRE) oder Development Kit (JDK) in den Versionen 1.4, 1.5,1.6
UModel Unterstützung: Der Import von Typen wird für alle Class Archives unterstützt, die für dieseUmgebungen vorgesehen sind, d.h. die den Java Virtual Machine Spezifikationenentsprechen.
C# 2.0 / C# 3.0: / C# 4.0 / Visual Basic 7.1, 8.0 und 9.0 .NET Framework 2.0, 3.0, 3.5 und 4.0
UModel Unterstützung: Der Import von Typen wird für Assemblies unterstützt, die für folgende Umgebungenvorgesehen sind:
.NET Framework 1.1, 2.0, 3.0, 3.5 und 4.0
.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 MS .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.
© 2010 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 129Projekte und Code Engineering
Altova UModel 2010
2. Wählen Sie die Sprache und die Runtime Version und klicken Sie auf "Weiter".Daraufhin wird das Dialogfeld "Ausgewählte Binärtypen importieren" geöffnet.
3. Klicken Sie auf die Schaltfläche "Hinzufügen" und wählen in im angezeigten Popup-Fenster das Class Archive aus, z.B. Class Archives von Java Runtime... .
130 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2010 Altova GmbHAltova UModel 2010
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 importierenmöchten (in der Abbildung unten die ersten drei). Klicken Sie anschließend auf"Weiter".
Daraufhin wird das Dialogfeld Optionen für den Import von Binärdateien geöffnet.
5. Wählen Sie die benötigten Optionen aus und klicken Sie zum Fortfahren auf "Weiter".
© 2010 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 131Projekte und Code Engineering
Altova UModel 2010
6. Definieren Sie das Importziel oder klicken Sie auf das Kontrollkästchen "In neues Paketimportieren" und anschließend auf "Weiter".
7. Wählen Sie im Dialogfeld die Eigenschaften für die Generierung einesInhaltsdiagramms aus und klicken Sie zum Fortfahren auf "Weiter".Beachten Sie, dass Sie für jedes Paket ein einzelnes Diagramm generieren können,aber auch die Möglichkeit haben, ein einziges Übersichtsdiagramm zu erzeugen.
132 Projekte und Code Engineering Importieren von Java-, C#- und VB-Binärdateien
© 2010 Altova GmbHAltova UModel 2010
8. Wählen Sie die gewünschten Paketabhängigkeitsoptionen aus und klicken Sie auf"Fertig stellen", um den Importvorgang fertig zu stellen.In der Abbildung unten sehen Sie das Diagramm, das die Paketabhängigkeiten derJava-Binärdateien enthält.
9. Klicken Sie auf die anderen Register, um die Class Files usw. zu sehen.
Bitte beachten Sie:Wenn Sie auf das Link-Symbol eines Ordners klicken, wird das referenzierte Diagrammautomatisch geöffnet.
© 2010 Altova GmbH
Importieren von Java-, C#- und VB-Binärdateien 133Projekte und Code Engineering
Altova UModel 2010
134 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2010 Altova GmbHAltova UModel 2010
7.4 Synchronisieren von Modell und Quellcode
UModel gestattet Ihnen, Modell und Code von beiden Seiten zu synchronisieren.
Code- / Modellsynchronisierung:Code kann, wie unten beschrieben, auf unterschiedlichen Ebenenzusammengeführt/synchronisiert werden. Wenn Sie das Kontextmenü verwenden und z.B. mitder rechten Maustaste auf eine Klasse klicken, wird Ihre Auswahl im Kontextmenü in derMenüoption widergespiegelt. Beachten Sie: Über das Menü "Projekt" können Sie ein Projekt nurauf der Root-/Projektebene synchronisieren.
Ebene Projekt, Root-Paket:1. Rechtsklicken Sie auf das Root-Paket.2. Wählen Sie eine der Optionen zum Zusammenführen von Code: "Merge Programm...",
oder "Merge UModel Projekt..".Alternativ dazu verwenden Sie das Menü "Projekt".
Ebene Paket:1. Wählen Sie das/die gewünschte(n) Paket(e) mit Hilfe von Umschalt oder Strg + Klick
aus..2. Rechtsklicken Sie auf die Auswahl und wählen Sie die Optionen zum Zusammenführen
von Code:"Merge Programm..." oder "Merge UModel Project..".
Ebene Klasse:1. Wählen Sie die gewünschte(n) Klasse(n) mit Hilfe von Umschalt oder Strg + Klick aus.2. Rechtsklicken Sie auf die Auswahl und wählen Sie die Optionen zum Zusammenführen
von Code:"Merge Programm..." oder "Merge UModel Project..".
Definieren Sie die Synchronisierungsoptionen durch Auswahl von:1. Projekt | Synchronisierungsoptionen.
Über die einzelnen Register können Sie bestimmte Merge-Einstellungen definieren.2. KlickenSie auf die Schaltfläche "Projekteinstellungen" um die jeweiligen
Programmierspracheneinstellungen auszuwählen.3. Definieren Sie die gewünschten Einstellungen und klicken Sie auf OK.
© 2010 Altova GmbH
Synchronisieren von Modell und Quellcode 135Projekte und Code Engineering
Altova UModel 2010
Bitte beachten Sie:Unter Umständen wird beim Synchronisieren von Code ein Dialogfeld angezeigt, indem Sie aufgefordert werden, Ihr UModel-Projekt vor dem Synchronisieren zuaktualisieren.
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.
Aktualisieren Ihres Modells - Auswirkungen:Zum Aktualisieren Ihres Modells, stehen, wie oben erwähnt, verschiedene Methoden zurVerfügung:
Projekt | Modell anhand von Code überschreiben- Dabei werden alle Verzeichnisse (Projektdateien) aller verschiedenen von Ihnen inIhrem Projekt definierten Codesprachen überprüft.- Neue Dateien werden ermittelt und zum Projekt hinzugefügt.- In Ihrem Meldungsfenster erscheint der Eintrag "Quelldateien werden in 'C:\UMTest'gesammelt".
Rechtsklicken Sie in der Modellstruktur auf eine Klasse, Schnittstelle,... und wählenSie die Option Code Engineering | UModel-Klasse anhand von Programmcodeüberschreiben- Daraufhin wird die ausgewählte Klasse (Schnittstelle,...) Ihres Projekts aktualisiert.- Da fehlende Klassen nicht ausgewählt werden können, wird nichts zum Projekthinzugefügt.
Rechtsklicken Sie auf eine Komponente in der Modell-Struktur (normalerweiseinnerhalb das Pakets "Component View") und wählen Sie die Option CodeEngineering | UModel-Komponente anhand von Programmcode überschreiben. - Daraufhin wird nur das entsprechende Verzeichnis (bzw. die entsprechendeProjektdatei) aktualisiert.
136 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2010 Altova GmbHAltova UModel 2010
- Neue Dateien im Verzeichnis (in der Projektdatei) werden ermittelt und zum Projekthinzugefügt.- In Ihrem Meldungsfenster erscheint der Eintrag "Quelldateien werden in 'C:\UMTest'gesammelt".
SPL-Vorlagen:SPL-Vorlagen werden bei der Generierung von Java-, C#- und VB-Code verwendet.
So ändern Sie die vorgegebenen SPL-Vorlagen:
1. Suchen Sie die vordefinierten SPL-Vorlagen im Standardverzeichnis: ...\UModel2010\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 ...\UModel2010\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".
Wählen Sie anschließend einen der unten gezeigten Menüoptionen, um denSynchronisierungsvorgang zu initiieren.
Projekt | Merge Programmcode aus UModel Projekt. Nähere Informationen dazusiehe Round-Trip Engineering (Modell - Code - Modell) oder
Projekt | Merge UModel Projekt aus Programmcode. Nähere Informationen dazusiehe Round-Trip Engineering (Code - Modell - Code).
Bitte beachten Sie:SPL-Vorlagen werden nur verwendet/aufgerufen, wenn neuer Code generiert wird, d.h.wenn neue Klassen, Operationen usw. zum Modell hinzugefügt wurden. BestehenderCode ruft die SPL-Vorlagen nicht auf bzw. greift nicht darauf zu.
© 2010 Altova GmbH
Synchronisieren von Modell und Quellcode 137Projekte und Code Engineering
Altova UModel 2010
7.4.1 Tipps zur Synchronisierung
Umbenennen von Classifiern und Reverse Engineering: Der unten beschriebenen Vorgang beim Reverse Engineering oder der automatischenSynchronisierung bezieht sich sowohl auf die Standalone-Applikation als auch auf diePlug-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 beimReverse Engineering automatisch erstellt werden, oder wenn ein Diagramm mit dem Befehl "Inneuem Diagramm anzeigen | Inhalt" erstellt wird. Der neue Classifier wird an derStandardposition im Diagramm eingefügt. Diese ist wahrscheinlich nicht mit der vorherigenPosition identisch.
Sie erhalten in UModel nun Hilfe beim Refactoring von Klassen. Nähere Informationen dazufinden Sie unter Refactoring und Synchronisierung von Code.
So aktivieren Sie die automatische Generierung von Komponentenrealisierungen:
Wählen Sie den Menübefehl Extras | Optionen, klicken Sie auf das Register CodeEngineering und aktivieren Sie die Option Fehlende Komponentenrealisierungengenerieren.
Automatische Generierung von KomponentenrealisierungenUModel kann nun 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 streng
getrennt.
Automatische Komponentenrealisierungen werden für einen Classifier generiert, dem EINE(und nur EINE) Komponente zugewiesen werden kann. ohne Komponentenrealisierung oder eine im Namespace einer Codesprache enthaltene Komponente
Die Art, wie die Komponente gesucht wird, ist in den beiden Fällen unterschiedlich:
Komponente, die eine Code-Projektdatei repräsentiert (Eigenschaft "projectfile" ist aktiviert) wenn es EINE Komponente gibt, die Classifier im Paket, das sie enthält, hat/realisiert wenn es EINE Komponente gibt, die Classifier in einem Unterpaket, des Pakets, das
sie enthält, hat/realisiert (von oben nach unten) wenn es EINE Komponente gibt, die Classifier in einem der übergeordneten Pakete
hat/realisiert (von unten nach oben) wenn es EINE Komponente gibt, die Classifier in einem Unterpaket eines der
übergeordneten Paket hat/realisiert (von oben nach unten)
Komponente, die ein Verzeichnis repräsentiert (Eigenschaft "directory" ist aktiviert) wenn es EINE Komponente gibt, die Classifier im Paket, das sie enthält, hat/realisiert wenn es EINE Komponente gibt, die Classifier in einem der übergeordneten Pakete
hat/realisiert (von unten nach oben)
Anmerkungen: Die Option "Code Engineering | Fehlende Komponentenrealisierungen generierten
138 Projekte und Code Engineering Synchronisieren von Modell und Quellcode
© 2010 Altova GmbHAltova UModel 2010
" muss aktiviert sein. Sobald bei einem der obigen Schritte EINE verwendbare Komponente gefunden wird,
wird diese Komponente verwendet und die restlichen Schritte werden ignoriert!
Fehler/Warnungen: Wenn keine verwendbare Komponente gefunden wird, wird eine Warnmeldung
generiert (Meldungsprotokoll) Wenn mehrere verwendbare Komponenten gefunden werden, wird eine Fehlermeldung
generiert (Meldungsprotokoll)
© 2010 Altova GmbH
Synchronisieren von Modell und Quellcode 139Projekte und Code Engineering
Altova UModel 2010
7.4.2 Refactoring und Synchronisierung von Code
Beim Refactoring von Code müssen oft Klassennamen geändert/aktualisiert werden. InVersionen vor UModel 2009 wurden bei der Synchronisierung von Code die "alten" Klassengelöscht und neue eingefügt.
Falls in UModel beim Reverse Engineering festgestellt wird, dass neue Typen hinzugekommen/umbenannt worden sind, wird nun in UModel ein Dialogfeld geöffnet. Die neuen Typen werdenin der Spalte "Neuer Name" geöffnet, während der vom Programm als ursprünglicher Typnameangenommene Name in der Spalte "Umbenannt von" aufgelistet wird. Diese Annahmen werdenvon UModel aufgrund von Namespace, Klasseninhalt, Basisklassen und anderen Datengetätigt.
Wenn eine Klasse umbenannt wurde, wählen Sie den früheren Klassennamen über dieAuswahlliste in der Spalte "Umbenannt von" aus, z.B. C1. Damit stellen Sie sicher, dass alledamit in Zusammenhang stehenden Daten beibehalten werden und das Code Engineeringkorrekt erfolgt.
Ä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 angepasstwerden soll, bevor Sie die Synchronisierung starten. Beachten Sie, dass Sie auch dieMöglichkeit haben, auch die Klassenkonstruktoren zu ändern.
140 Projekte und Code Engineering Voraussetzungen für Forward Engineering
© 2010 Altova GmbHAltova UModel 2010
7.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 Komponentendiagrammeine Realisierung 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:1. Wählen Sie die Komponente in der Modell-Struktur oder im Diagramm aus.2. Aktivieren Sie das Kontrollkästchen "use for code engineering".
© 2010 Altova GmbH
Voraussetzungen für Forward Engineering 141Projekte und Code Engineering
Altova UModel 2010
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 CodeEngineering-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 diesemPaket entfernt.
142 Projekte und Code Engineering Generieren von Java-Code aus UModel-Elementen und umgekehrt
© 2010 Altova GmbHAltova UModel 2010
7.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 dem
Modell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER umdie HTML-Version der Tabelle in Ihrem Browser zu öffnen.
© 2010 Altova GmbH
Generieren von C#-Code aus UModel Elementen und umgekehrt 143Projekte und Code Engineering
Altova UModel 2010
7.7 Generieren von C#-Code aus UModel Elementen und umgekehrt
In der nachstehenden Tabelle sehen Sie die Eins-zu-Eins-Entsprechungen zwischen:
UModel-Elementen und C#-Code-Elementen bei Ausgabe eines Modells in Code C#-Code-Elementen und UModel -Modellelementen bei Eingabe von Code in das
Modell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER umdie HTML-Version der Tabelle in Ihrem Browser zu öffnen.
144 Projekte und Code Engineering XML Schema von/zu UModel Elementen
© 2010 Altova GmbHAltova UModel 2010
7.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 inCode
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 umdie HTML-Version der Tabelle in Ihrem Browser zu öffnen.
© 2010 Altova GmbH
Konvertierung VB.NET-Code - UModel-Elemente 145Projekte und Code Engineering
Altova UModel 2010
7.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 Code VB.NET-Code-Elementen und UModel-Modellelementen bei der Eingabe von Code in
das Modell
In der Abbildung sehen Sie nur einen kleinen Abschnitt der Tabelle. Klicken Sie bitte HIER umdie HTML-Version der Tabelle in Ihrem Browser zu öffnen.
146 Projekte und Code Engineering Inkludieren anderer UModel-Projekte
© 2010 Altova GmbHAltova UModel 2010
7.10 Inkludieren anderer UModel-Projekte
UModelUModel wird mit mehreren Dateien geliefert, die in ein UModel-Projekt inkludiert werdenkönnen. Wenn Sie auf eines der Java-Register klicken, können Sie Java lang-Klassen,Schnittstellen und Pakete in Ihr Projekt inkludieren, indem Sie eine der mitgelieferten Dateienauswählen.
1. Wählen Sie Projekt | Unterprojekt inkludieren, um das Dialogfeld "Inkludieren" zuöffnen.
2. Klicken Sie auf die gewünschte UModel-Projektdatei und klicken Sie auf OK.
UModel-Projekte können in andere UModel-Projekte inkludiert werden. Platzieren Sie dazu diejeweiligen *.ump-Dateien in:
...\UModel2010\UModelInclude damit Sie auf dem Register "Basic" angezeigt werdenoder
...\UModel2010\UModelInclude\Java1.4 / Java5.0, damit Sie auf dem Register "Java"angezeigt werden.
Bitte beachten Sie:Eine Include-Datei, die alle Microsoft .NET Framework 2.0 Arten enthält, finden Sie aufdem Register C# 2.0.
So zeigen Sie alle derzeit importierten Projekte an:
Wählen Sie die Menüoption Projekt | Unterprojekt als Projekt öffnen. Das Menü, das erscheint, enthält die aktuell inkludierten Unterprojekte.
© 2010 Altova GmbH
Inkludieren anderer UModel-Projekte 147Projekte und Code Engineering
Altova UModel 2010
So erstellen Sie ein benutzerdefiniertes Register/einen benutzerdefinierten Ordner:1. Navigieren Sie zum Ordner ...\UModel2010\UModelInclude und erstellen Sie Ihren
Ordner unterhalb davon bzw. fügen Sie ihn hinzu, d.h. ...\UModelInclude\myfolder.
So erstellen Sie beschreibenden Text zu jeder UModel Projektdatei:1. Erstellen Sie eine Textdatei mit demselben Namen wie die *.ump-Datei und platzieren
Sie sie in denselben Ordner.So wird z.B. für die Datei MyModel.ump eine beschreibende Datei namesMyModel.txt benötigt. Stellen Sie bitte sicher, dass die Codierung dieser TextdateiUTF-8 ist.
So entfernen Sie ein inkludiertes Projekt:1. Klicken Sie in der Modell-Strukturansicht auf das inkludierte Paket und drücken Sie die
Entf-Taste. 2. Sie werden gefragt, ob Sie mit dem Löschen fortfahren wollen.3. Klicken Sie auf OK, um die inkludierte Datei aus dem Projekt zu löschen.
Bitte beachten Sie: Um ein Projekt aus dem Dialogfeld "Inkludieren" zu löschen oder zu entfernen,
löschen oder entfernen Sie die .ump-Datei (MyModel.ump) aus dem jeweiligenOrdner.
148 Projekte und Code Engineering Zusammenführen von UModel-Projekten
© 2010 Altova GmbHAltova UModel 2010
7.11 Zusammenführen von UModel-Projekten
Sie können nun zwei verschiedene UModel-Projektdateien zu einem gemeinsamen UModel *.ump Modell zusammenführen. Dies ist hilfreich, wenn mehrere Personen gleichzeitig am selbenProjekt arbeiten oder wenn Sie Ihre Arbeit einfach in einem einzigen Modell zusammenführenmöchten.
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 unddie relevanten 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.Es wird 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 (undeine fortlaufende Nummerierung wird an den Namen des Diagramms angehängt, z.B:activity1 usw.) und das ursprüngliche Diagramm wird beibehalten.
Falls keine Unterschiede vorhanden sind, werden identische Diagramme ignoriert undes werden keine Änderungen vorgenommen.
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 entsprechendeElement in der Modell-Struktur angezeigt.
Der Dateiname der zusammengeführten Datei, also der ersten Datei, die Sie geöffnethaben, wird beibehalten.
© 2010 Altova GmbH
Freigeben von Paketen und Diagrammen 149Projekte und Code Engineering
Altova UModel 2010
7.12 Freigeben von Paketen und Diagrammen
UModel gestattet Ihnen, Pakete und eventuell darin enthaltene UML-Diagramme freizugebenund in mehreren Projekten zu verwenden. Pakete können mittels Referenz oder in Form einerKopie in andere UModel-Projekte inkludiert werden.
Voraussetzungen für freigegebene Pakete:
Objektbeziehungen zu anderen Paketen außerhalb des freigebenen Bereichs sind nichtzulässig.
So verwenden Sie ein Paket in mehreren Projekten:1. Rechtsklicken Sie auf dem Register "Modell-Struktur" auf ein Paket und wählen Sie
Unterprojekt | Paket freigeben.
In der Modell-Struktur wird unterhalb des freigegebenen Pakets ein"freigegeben"-Symbol angezeigt. Dieses Paket kann nun in jedes beliebige andere UModel-Projekt inkludiert werden.
So inkludieren/importieren Sie einen freigegebenen Ordner in ein Projekt:1. Öffnen Sie das Projekt, das das freigegebene Paket enthalten soll (in diesem Beispiel
ein leeres Projekt).
2. Wählen Sie den Menüeintrag Projekt | Unterprojekt inkludieren...3. Klicken Sie auf die Durchsuchen-Schaltfläche, wählen Sie das Projekt, das das
freigegebene Paket enthält, aus und klicken Sie auf "Öffnen".
150 Projekte und Code Engineering Freigeben von Paketen und Diagrammen
© 2010 Altova GmbHAltova UModel 2010
Im Dialogfeld "Inkludieren" können Sie das Paket/Projekt in Form einer Referenz oderals Kopie inkludieren.
4. Wählen Sie die gewünschte Option ("Durch Referenz") und klicken Sie auf OK.
Im neuen Paket ist nun das Paket "Deployment View" zu sehen. Das Quellprojekt 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:
© 2010 Altova GmbH
Freigeben von Paketen und Diagrammen 151Projekte und Code Engineering
Altova UModel 2010
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 entsprechendeElement auf dem Register "Modell-Struktur" angezeigt.
152 Projekte und Code Engineering Freigeben von Paketen und Diagrammen
© 2010 Altova GmbHAltova UModel 2010
© 2010 Altova GmbH
UML-Vorlagen 153Projekte und Code Engineering
Altova UModel 2010
7.13 UML-Vorlagen
UModel unterstützt nun die Verwendung von UML-Vorlagen (Templates) und das Mappendieser Vorlagen auf/von Java 5.0, 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, wennder Vorlagenparameter ausgewählt ist.
Anzeige der Vorlagensignatur in UModel:
Klassenvorlage mit dem Namen MyVector mit dem formalen Vorlagenparameter "T",der in einem gestrichelten Rechteck angezeigt wird.
Formale Parameter ohne Typinfo (T ) sind implizit Classifier: Class, Datatype,Enumeration, PrimitiveType, Interface. Alle anderen Parametertypen müssen 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 intvector
Vorlage vom Typ MyVector, wobei der Parameter T durch int ersetzt wird "Ersetzt durch" wird angezeigt durch - >.
Verwendung von Vorlagen in Eigenschaften/Operationen:
154 Projekte und Code Engineering UML-Vorlagen
© 2010 Altova GmbHAltova UModel 2010
Eine anonyme Vorlagenverwendung: Eigenschaft MyFloatVector vom Typ MyVector<T->float>
Vorlagen können auch beim Definieren von Eigenschaften oder Operationen definiert werden.Die Autokomplettierungsfunktion hilft Ihnen, die Syntaxvorgaben einzuhalten.
Operation1 gibt einen Vektor von floats zurück.
© 2010 Altova GmbH
UML-Vorlagen 155Projekte und Code Engineering
Altova UModel 2010
7.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 gesetztwerden kann, 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 "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>
156 Projekte und Code Engineering UML-Vorlagen
© 2010 Altova GmbHAltova UModel 2010
7.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 anonymgebundene Klassen. Vorlagenverwendungen können wie unten gezeigt im Klassennamen-Felddefiniert werden.
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>
© 2010 Altova GmbH
UML-Vorlagen 157Projekte und Code Engineering
Altova UModel 2010
7.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
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.
158 Projekte und Code Engineering Projekteinstellungen
© 2010 Altova GmbHAltova UModel 2010
7.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.
© 2010 Altova GmbH
Verbesserung der Performance 159Projekte und Code Engineering
Altova UModel 2010
7.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 Grafikkarteverwenden (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.
162 Erstellen von Modellbeziehungen
© 2010 Altova GmbHAltova UModel 2010
8 Erstellen von Modellbeziehungen
Modellbeziehungen können auf verschiedene Arten erstellt und in Diagramme eingefügtwerden:
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 jeweiligenKlasse in der anderen an.
© 2010 Altova GmbH
163Erstellen von Modellbeziehungen
Altova UModel 2010
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 Navigationspfeilverschwindet. 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 Elementan eine andere Stelle desselben Elements. Daraufhin wird eine Objektbeziehung aufsich selbst angezeigt.
Automatische Anzeige von Assoziationen in DiagrammenBeim 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 generierteAttribut/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.
164 Erstellen von Modellbeziehungen
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Assoziationen, Realisierungen und Abhängigkeiten 165Erstellen von Modellbeziehungen
Altova UModel 2010
8.1 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 eineCollection-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): Schnittstellenrealisierung Generalisierung Assoziation
Ein Artefakt in der Deployment-Ansicht hat die folgenden Ziehpunkte: Manifestation Assoziation Verteilung
Erstellen von Beziehungen mit Hilfe der Symbole der Symbolleiste:Angenommen, Sie haben zwei Elemente in einem Modellierungsdiagramm,
1. Klicken Sie auf das Symbol, das die Beziehung darstellt, die Sie erzeugen möchten,z.B. Assoziation, Aggregation, oder Komposition.
2. Ziehen Sie es von einem Objekt auf das andere und lassen Sie die Maustaste los,wenn das Zielelement markiert erscheint.
166 Erstellen von Modellbeziehungen Assoziationen, Realisierungen und Abhängigkeiten
© 2010 Altova GmbHAltova UModel 2010
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 generierteAttribut/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, umdiese Art 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.
Wählen Sie den Collection-Typ im Popup-Menü aus.
© 2010 Altova GmbH
Assoziationen, Realisierungen und Abhängigkeiten 167Erstellen von Modellbeziehungen
Altova UModel 2010
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 Bindingverwendet wird, nicht sichtbar ist.
Der konkrete Collection-Typ von "myColors" wird immer noch im myColorsContainer, nicht aberin der Assoziation angezeigt.
Über das Register "Diagrammbearbeitung" des Dialogfelds Extras | Optionen können Sie dieVorlagen definieren, in denen dieses Verhalten angewendet werden soll und ob die Collectionsaufgelöst werden sollen.
168 Erstellen von Modellbeziehungen Anzeigen von Modellbeziehungen
© 2010 Altova GmbHAltova UModel 2010
8.2 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.
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.
170 Generieren von UML-Dokumentation
© 2010 Altova GmbHAltova UModel 2010
9 Generieren von UML-Dokumentation
Altova Website: UML-Projektdokumentation
Mit dem Befehl Projekt | Dokumentation generieren... wird detaillierte Dokumentation zuIhrem UML-Projekt in den Formaten HTML, MS Word oder RTF generiert. Anmerkung: UmDokumentation in MS Word zu generieren, muss MS Word (Version 2000 oder höher) instaliertsein.
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)und wählen Sie den Befehl "Dokumentation generieren". Beim Element kann es sich um einenOrdner, eine Klasse eine Schnittstelle usw. handeln. Die Dokumentationsoptionen sind inbeiden Fällen dieselben.
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/oderVB-Unterprojekte (Profile) generiert wird, wenn diese Optionen auf dem Register "Inkludieren"ausgewählt ist.
Die Option Diagramme einbetten ist für die Ausgabeoptionen MS Word und RTF aktiviert.Wenn diese Option ausgewählt ist, werden Diagramm in die generierte Datei eingebettet.Diagramme werden als PNG-Dateien (für HTML) oder PNG/EMF-Dateien (für MS Word undRTF) erstellt und über Objektlinks in der Ergebnisdatei angezeigt.
Mit der Option Ordner für Diagramme erstellen wird unterhalb des ausgewähltenAusgabeordners ein Unterordner erstellt, der bei Ausgabe der Dokumentation alle Diagrammeenthält.
Mit der Option Ausgabe auf mehrere Dateien aufteilen wird für jedes Modellierungselement,das bei Generierung einer einzigen Ausgabedatei in der Inhaltsverzeichnisübersicht zu sehen
© 2010 Altova GmbH
171Generieren von UML-Dokumentation
Altova UModel 2010
ist, eine Ausgabedatei erstellt. Z.B. gibt es eine Klasse C1 mit einer geschachtelten KlasseCNest; C1.html enthält alle Informationen zu C1 und CNest sowie alle ihre Attribute undEigenschaften usw.
Mit der Option CSS in HTML einbetten können Sie eine vorhandene (referenzierte) CSS-Dateiin die HTML-Dokumentation einbetten. Wenn Sie die Option deaktivieren, wird die Referenz zurCSS-Datei beibehalten und die Datei selbst bleibt extern.
Über die Option Links zu lokalen Dateien generieren können Sie festlegen, ob diegenerierten Links absolute oder relative Links zur Ausgabedatei sein sollen.
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 desKontrollkästchens "Inkludierte Unterprojekte" deaktiviert werden kann.
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 Klasseangezeigt werden soll.
Mit der Option "Jedes Element nur einmal erweitern" wird nur immer jeweils einClassifier im selben Bild/Diagramm erweitert.
172 Generieren von UML-Dokumentation
© 2010 Altova GmbHAltova UModel 2010
Auf dem Register "Schriftarten" können Sie die Schriftarteinstellungen für die verschiedenenÜberschriften und Textinhalte anpassen.
© 2010 Altova GmbH
173Generieren von UML-Dokumentation
Altova UModel 2010
In den folgenden Abbildungen sehen Sie die generierte Dokumentation für die DateiBank_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.
174 Generieren von UML-Dokumentation
© 2010 Altova GmbHAltova UModel 2010
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 eineEigenschaft klicken, gelangen Sie zu ihrer Definition. Die einzelnen Hierarchieklassen sowie dergesamte unterstrichene Text sind durch Hyperlinks verbunden.
176 UML-Diagramme
© 2010 Altova GmbHAltova UModel 2010
10 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 diedynamische Ansicht dargestellt wird. UModel unterstützt alle vierzehn Diagramme der UML 2.3-Spezifikation sowie XML-Schema- und Business Modeling Notation-Diagramme.
Zu den Verhaltensdiagrammen gehören Aktivitäts-, Zustands-, Protokoll-Zustands- und UseCase-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 Sequendiagrammen, Zeitverlaufsdiagrammen; Guard-Bedingungen, Zustandsnamen,Aktivitätsnamen usw.
© 2010 Altova GmbH
Verhaltensdiagramme 177UML-Diagramme
Altova UModel 2010
10.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übersichtsdiamm
Sequenzdiagramm
Zeitverlaufsdiagramm
178 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.1.1 Aktivitätsdiagramm
Altova Website: UML-Aktivitätsdiagramm
Aktivitätsdiagramme eignen sich, um reale Arbeitsabläufe von Geschäftsprozessen zumodellieren und um anzuzeigen, welche Aktionen dabei erforderlich sind und welcheAbhängigkeiten diese haben. Im Aktivitätsdiagramm wird die Reihenfolge von Aktivitätenbeschrieben. Es wird sowohl bedingte als auch parallele Verarbeitung unterstützt. DasAktivitätsdiagramm ist eine Variante des Zustandsdiagramms, wobei die Zustände hierAktivitä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.
© 2010 Altova GmbH
Verhaltensdiagramme 179UML-Diagramme
Altova UModel 2010
Einfügen von Aktivitätsdiagrammelementen
Verwendung der Symbolleistenschaltflächen:1. Klicken Sie in der Aktivitätsdiagrammsymbolleiste auf das gewünschte
Aktivitätsdiagramm-Symbol.2. Klicken Sie in das Aktivitätsdiagramm, um das Element einzufügen.
Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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".
180 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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".
© 2010 Altova GmbH
Verhaltensdiagramme 181UML-Diagramme
Altova UModel 2010
Erstellen von Verzweigungen und Merges
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, dahersollten die Guards einander gegenseitig ausschließen.
In diesem Beispiel müssen die (BankView) Referenzen validiert werden. branch1 (Verzweigung1) hat den Guard "reference missing" (=Referenz fehlt). Diese
Transition endet im Abbruch der Aktivität. branch2 hat den Guard "valid" (= gültig). Diese Transition führt zur Aktivität
collectAccountInfos (Kontoinformationen abrufen).
1. Klicken Sie in der Symbolleiste auf das Symbol Verzweigungsknoten 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ähere Informationen dazu finden Sie unter "Einfügen einer Aktion (Aufrufoperation)".
182 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
5. Geben Sie auf dem Register "Eigenschaften" die Guard-Bedingung "valid" ein.
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 Diagrammnicht validiert oder überprüft.
Erstellen eines Merge:
© 2010 Altova GmbH
Verhaltensdiagramme 183UML-Diagramme
Altova UModel 2010
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 vereinigendenAktionen und ziehen Sie die Pfeile auf das Verbindungsknotensymbol.
Aktivitätsdiagramm-Elemente
Aktion (Aufrufverhalten)Fügt das Aktionselement Aufrufverhalten ein, welches ein bestimmtes Verhalten direkt aufruft.Wenn Sie über die Auswahlliste Verhalten ein vorhandenes Verhalten auswählen, z.B.HandleDisplayException, wird innerhalb des Elements das Symbol eines Rechens angezeigt.
Aktion (Aufrufoperation)Fügt die Aktion "Aufrufverhalten" ein, welche ein bestimmtes Verhalten als Methode direktaufruft. Nähere Informationen finden Sie unter "Einfügen einer Aktion (Aufrufoperation)".
EreignisannahmeaktionFügt die Ereignisannahmeaktion ein, welche auf das Eintreten eines Ereignisses wartet, dasbestimmte Bedingungen erfüllt.
184 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Ereignisannahmeaktion (Zeitereignis)Fügt eine Ereignisannahmeaktion ein, die durch ein Zeitereignis ausgelöst wird, welches einZeitintervall - 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 undmehrere ausgehende mit Guards versehene Transitionen. Nähere Informationen dazu findenSie unter "Erstellen einer Verzweigung".
VerbindungsknotenFügt einen Verbindungsknoten ein, der mehrere durch einen Verzweigungsknoten definiertealternative Transitionen zusammenführt. Die gleichzeitig ablaufenden Prozesse werden dabeinicht synchronisiert, sondern es wird einer der Prozesse ausgewählt.
© 2010 Altova GmbH
Verhaltensdiagramme 185UML-Diagramme
Altova UModel 2010
StartknotenDer Anfang der Aktivität. Eine Aktivität kann mehrere Startknoten haben.
AktivitätsendknotenDas Ende der Aktivität. Eine Aktivität kann mehrere Endknoten haben. Alle Flüsse in derAktivität werden 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. DieseBeendung hat 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 Parallelisierungsknotendefinierte Flüsse.
Synchronisationsknoten (horizontal)Fügt einen horizontalen Parallelisierungsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch einen Parallelisierungsknotendefinierte Flü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
186 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
werden. Dem Output Pin wird automatisch ein Name zugewiesen, der der UML-Eigenschaftdieser Aktion - z.B. "result" - entspricht.
Das Output Pin-Symbol kann nur auf jene Aktivitätselemente platziert werden, bei denen der
Mauszeiger sich in eine Hand verwandelt . Wenn Sie das Symbol mit der Maus ziehen, wirdes am Rand des Elements neu positioniert.
WertpinFügt einen Wertpin ein. Dabei handelt es sich um einen Input Pin, der für eine Aktion einenWert bereitstellt, der nicht aus einem eingehenden Objektfluss stammt. Er wird als ein InputPin-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,die dem Typ des Objektknotens entsprechen.
PufferknotenFügt einen Pufferknoten ein, der als Puffer für mehrere eingehende und ausgehende Flüssevon anderen Objektknoten dient.
DatenspeicherknotenFügt einen Datenspeicherknoten ein. Dabei handelt es sich um einen speziellen Pufferknoten,der zum Speichern dauerhafter (d.h. nicht temporärer) Daten dient.
Aktivitätsbereich (horizontal)Fügt einen horizontalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art vonAktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaftengemeinsam haben. Dies entspricht oft Organisationseinheiten in einem Geschäftsmodell.
© 2010 Altova GmbH
Verhaltensdiagramme 187UML-Diagramme
Altova UModel 2010
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 durch
Aufziehen eines Rechtecks in der Umrandung einzeln ausgewählt werden. Klicken Sie auf die Umrandung oder den titel der ActivityPartition und ziehen Sie sie/
ihn, um diese an eine andere Stelle zu verschieben.
Aktivitätsbereich (vertikal)Fügt einen vertikalen Aktivitätsbereich ein. Dabei handelt es sich um eine Art vonAktivitätsgruppe, die zum Kennzeichnen von Aktionen dient, die einige Eigenschaftengemeinsam haben. 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 Eigenschaftengemeinsam haben. Beide Achsen haben editierbare Beschriftungen.
So entfernen Sie die Dim1, Dim2-Beschriftungen:1. Klicken Sie auf die Dimensionsbezeichnung, die Sie entfernen möchten z.B. Dim12. Doppelklicken Sie auf dem Register "Eigenschaften" auf den Eintrag Dim1, löschen Sie
ihn und bestätigen Sie den Vorgang mit der Eingabetaste.
188 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
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.
© 2010 Altova GmbH
Verhaltensdiagramme 189UML-Diagramme
Altova UModel 2010
Ausnahme-HandlerEin Ausnahme-Handler ist ein Element, das festlegt, welche Aktion ausgeführt werden soll,wenn während der Ausführung des geschützten Knotens ein bestimmtes Ausnahmeereignisauftritt.
Ein Ausnahme-Handler kann nur auf einen Inputpin einer Aktion gezogen werden.
AktivitätFügt eine Aktivität in das Aktivitätsdiagramm ein.
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.
190 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
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/Output eine Sammlung von Werten ist. Die Pfeile, die in den Mengenverarbeitungsbereichhinein oder daraus heraus weisen , legen die jeweilige Art des Erweiterungsknotens fest.
© 2010 Altova GmbH
Verhaltensdiagramme 191UML-Diagramme
Altova UModel 2010
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
zu einer anderen Aktion enthält:
1. Rechtsklicken Sie auf den Kontrollflusspfeil und wählen Sie Neu | InterruptingEdge.
Bitte beachten Sie:Sie können eine InterrupingEdge auch durch Klicken auf den Unterbrechungsbereich,Rechtsklick in das Fenster "Eigenschaften" und Auswahl des Popup-Menübefehls"InterruptingEdge hinzufügen" hinzufügen.
192 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.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,beschrieben werden. Im Allgemeinen dienen diese Diagramme dazu, das Verhalten einesObjekts in verschiedenen Anwendungsfällen (Use Cases) zu beschreiben. EinZustandsautomat 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 nichtunterbrochen werden können, z.B. eine Start-Transition, ein interner Fehler / Adminbenachrichtigen.
Zustandsaktivitäten (Verhalten), welche mit Zuständen verknüpft sind, sind längerandauernde Prozesse, die durch andere Ereignisse unterbrochen werden können, z.B. dasWarten auf Verbindungsaufbauanfragen.
Beachten Sie, dass die in den folgenden Abschnitten gezeigten Zustandsdiagramme im UModelOrdner ...\UModelExamples im Beispiel Bank_MultiLanguage zur Verfügung stehen.
© 2010 Altova GmbH
Verhaltensdiagramme 193UML-Diagramme
Altova UModel 2010
Einfügen von Zustandsdiagrammelementen
Einfügen über die Symbole der Symbolleiste:1. Klicken Sie in der Zustandsdiagramm-Symbolleiste auf das entsprechende
Zustandsdiagramm-Symbol.
2. Klicken Sie in das Zustandsdiagramm, um das Element einzufügen.Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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önnendazu das Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einembeliebigen Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Zustandsdiagramm.
Erstellen von Zuständen, Aktivitäten und Transitionen
So fügen Sie einen einfachen Zustand ein:
1. Klicken Sie in der Symbolleiste auf das Zustandssymbol und anschließend in dasZustandsdiagramm, 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. In UModel können Sie über das Kontextmenü Aktivitäten sowie Regionen zu einemeinfachen Zustand hinzufügen.
So fügen Sie eine Aktivität zu einem Zustand hinzu:1. Rechtsklicken Sie auf das Element "Zustand", wählen Sie "Neu" und anschließend
einen der Einträge aus dem Kontextmenü.
194 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Sie haben die Wahl zwischen Aktionen aus der Kategorie: Eintritts, Austritt und Do.Aktivitäten werden im Zustandselement in ihren eigenen Bereich - wenn auch nicht ineine separate Region - platziert. Die Art der ausgewählten Aktivität wird als Präfix fürdie Aktivität verwendet z.B: entry / store current time (=Eintritt / aktuelle Zeitspeichern).
So löschen Sie eine Aktivität:1. Klicken Sie auf die entsprechende Aktivität im Zustandselement und drücken Sie die
Entf-Taste.
So erstellen Sie eine Transition zwischen zwei Zuständen:1. Klicken Sie auf den Transition-Ziehpunkt des Ausgangszustands (auf der rechten Seite
des Elements).2. Ziehen Sie den Transition-Pfeil mit der Maus auf den Ziel-Zustand.
Die Eigenschaften der Transition werden nun auf dem Register "Eigenschaften"angezeigt. Wenn Sie auf die Auswahlliste "Art" klicken, können Sie den Typ derTransition definieren: extern, intern oder lokal.
© 2010 Altova GmbH
Verhaltensdiagramme 195UML-Diagramme
Altova UModel 2010
Transitionen können einen Event Trigger, eine Guard-Bedingung und eine Aktion in derForm eventTrigger [Guard-Bedingung] /Aktivität haben.
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.
Syntax der Eigenschaft der Transition: Der Text vor der eckigen Klammer ist derTrigger, innerhalb der eckigen Klammer befindet sich die Guard-Bedingung und hinterdem Schrägstrich folgt die Aktivität. Bei Bearbeitung des Strings werden automatischdie entsprechenden 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-Strukturauswählen". Das Ereignis, die Aktivität und die Einschränkungselemente werden alleunterhalb der ausgewählten Transition angezeigt.
Hinzufügen eines Aktivitätsdiagramms zu einer Transition:UModel bietet die einzigartige Möglichkeit, zur näheren Beschreibung der Transition einAktivitätsdiagramm zu einer Transition hinzuzufügen.
1. Rechtsklicken Sie auf einen Transitionspfeil im Diagramm und wählen Sie Neu |Aktivitätsdiagramm.
196 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Daraufhin wird an der Position des Transitionspfeils ein Aktivitätsdiagrammfenster indas Diagramm 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 wechselnund die Transition näher zu definieren, z.B. um den Namen der Aktion in "Databaselogon" zu ändern.
Beachten Sie, dass ein neues Aktivitätsdiagrammregister zum Projekt hinzugefügtwurde. 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.
© 2010 Altova GmbH
Verhaltensdiagramme 197UML-Diagramme
Altova UModel 2010
5. Ziehen Sie gegebenenfalls das Aktivitätsfenster an die gewünschte Stelle im Diagrammund klicken Sie auf den Ziehpunkt zur Größenanpassung.
Wenn Sie das Aktivitätsfenster zwischen die beiden Zustände ziehen, wird dieTransition in die Aktivität und aus der Aktivität heraus angezeigt.
198 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Zusammengesetzte Zustände
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 zueinem zusammengesetzten Zustand; sobald die letzte Region eineszusammengesetzten Zustands gelöscht wurde, wird dieser wieder zu einem einfachenZustand.
So platzieren Sie einen Zustand in einen zusammengesetzten Zustand:1. Klicken Sie auf das gewünschte Zustandselement (z.B. Logging in User) und ziehen
Sie es in den Regionsbereich des zusammengesetzten Zustands.
Der Regionsbereich erscheint markiert, sobald Sie die Maustaste loslassen können.Das eingefügte Element ist nun Teil der Region und wird im Fenster "Modell-Struktur"als Child-Element der Region angezeigt.
© 2010 Altova GmbH
Verhaltensdiagramme 199UML-Diagramme
Altova UModel 2010
Wenn Sie den zusammengesetzten Zustand verschieben, werden alle darinenthaltenen Zustände mitverschoben.
Orthogonaler Zustand Diese Art von Zustand enthält einen zweiten Bereich bestehend aus zwei oder mehr Regionen,wobei die einzelnen Regionen auf Gleichzeitigkeit hinweisen.
Wenn Sie mit der rechten Maustaste auf einen Zustand klicken und Neu | Region auswählen,können Sie neue Regionen hinzufügen.
UnterautomatenzustandDieser Zustand dient zum Ausblenden der Einzelheiten eines Zustandsautomaten. DieserZustand hat keine Regionen, sondern ist mit einem separaten Zustandsautomaten verknüpft.
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.
200 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Beachten Sie bitte: Im Unterautomat wird automatisch ein Hyperlink angezeigt. WennSie darauf klicken, wird der referenzierte Zustandsautomat, in diesem Fall BankServer,geöffnet.
So fügen Sie Eintritts- / Austrittspunkte zu einem Unterautomatenzustand hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst einen Unterautomatenzustand(sichtbar auf dem Register "Eigenschaften") referenzieren. Dieser Unterautomat muss einen oder mehrere Eintritts- und Austrittspunkte enthalten
1. Klicken Sie in der Titelleiste auf das Symbol Verbindungspunktreferenz 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.
Daraufhin wird eine Eintrittspunktzeile zum Register "Eigenschaften" hinzugefügt unddas Aussehen des Verbindungspunktreferenz-Elements ändert sich.
© 2010 Altova GmbH
Verhaltensdiagramme 201UML-Diagramme
Altova UModel 2010
3. Fügen Sie auf dieselbe Weise einen Austrittspunkt hinzu. Wählen Sie dazu imKontextmenü den Befehl "Austritt hinzufügen".
Zustandsdiagramm-Elemente
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.
202 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
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 einesUnterautomatenzustands) eines Eintritts-/Austrittspunkts dar, der in derZustandsautomatenreferenz durch den Unterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst 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.
© 2010 Altova GmbH
Verhaltensdiagramme 203UML-Diagramme
Altova UModel 2010
Transitionen haben einen Event-Trigger, (eine) Guard-Bedingung(en), eine Aktion (Verhalten)und einen Zielzustand.
Unterstützte Ereignisunterelemente sind:
ReceiveSignalEvent, SignalEvent, SendSignalEvent, ReceiveOperationEvent,SendOperationEvent und ChangeEvent.
204 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.1.3 Protokoll-Zustandsautomat
Altova Website: UML-Protokoll-Zustandsdiagramme
Mit Hilfe von Protokoll-Zustandsautomaten wird eine Sequenz von Ereignissen dargestellt, aufdie ein Objekt reagiert, ohne dass das spezifische Verhalten dargestellt werden muss. Indiesem Diagramm werden die benötigte Ereignissequenz und die resultierenden Änderungenam Zustand des 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,haben aber weniger Modellierungselemente. Die Protokoll-Übergänge zwischen Zuständenkö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 resultierendeZustand nach dem Übergang sein muss.
© 2010 Altova GmbH
Verhaltensdiagramme 205UML-Diagramme
Altova UModel 2010
Einfügen von Protokoll-Zustandsdiagramm-Elementen
Einfügen über die Symbole der Symbolleiste:1. Klicken Sie in der Symbolleiste auf das Symbol "Protokoll-Zustandsautomat".
2. Klicken Sie in das Protokoll-Zustandsdiagramm, um das Element einzufügen.Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
Ziehen von bestehenden Elementen in das Protokoll-Zustandsdiagramm:Die meisten Elemente, die in anderen Protokoll-Zustandsdiagrammen vorkommen, können inein bestehendes Diagramm 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, um nach einembeliebigen Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Protokoll-Zustandsdiagramm.
So fügen Sie einen einfachen Zustand ein:
1. Klicken Sie in der Symbolleiste auf das Zustandssymbol und anschließend in 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/oderNachbedingung eingeben können. Verwenden Sie unbedingt die eckigen Klammern []und den Schrägstrich, wenn Sie die Bedingungen direkt eingeben.
Wenn Sie die Vor-/Nachbedingung im Fenster "Eigenschaften" eingeben, werden dieeckigen Klammern und der Schrägstrich automatisch in das Diagramm eingefügt.
206 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
So erstellen Sie Elemente zusammengesetzter Zustände und Unterautomatenzuständebzw. fügen diese ein:
Siehe Zusammengesetzte Zustände
Protokoll-Zustandsdiagramm-Elemente
ZustandEin einfaches Zustandselement mit nur einem Bereich.
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.
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 Zustandsautomatenverknüpft.
Startzustand (Pseudozustand)Der Beginn eines Prozesses.
EndzustandDas Ende der Abfolge von Prozessen.
Eintrittspunkt (Pseudozustand)
© 2010 Altova GmbH
Verhaltensdiagramme 207UML-Diagramme
Altova UModel 2010
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.
VerbindungspunktreferenzEine Verbindungspunktreferenz stellt eine Verwendung (als Teil einesUnterautomatenzustands) eines Eintritts-/Austrittspunkts dar, der in derZustandsautomatenreferenz durch den Unterautomatenzustand definiert ist.
So fügen Sie Eintritts- oder Austrittspunkte zu einer Verbindungspunktreferenz hinzu:
Der Zustand, mit dem der Punkt verbunden ist, muss selbst 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.
208 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Nähere Informationen dazu finden Sie unter Einfügen von Protokoll-Zustandselementen.
© 2010 Altova GmbH
Verhaltensdiagramme 209UML-Diagramme
Altova UModel 2010
10.1.4 Use Case-Diagramm
Eine Anleitung zum Hinzufügen von Klassen zum Diagramm finden Sie im Tutorial im Abschnitt Use Cases.
210 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.1.5 Kommunikationsdiagramm
Altova Website: UML-Kommunikationsdiagramme
In Kommunikationsdiagrammen werden Interaktionen d.h. Nachrichtenflüsse zwischenObjekten zur Laufzeit und die Beziehungen zwischen den miteinander in Wechselbeziehungstehenden Objekten dargestellt. Im Grunde dienen diese Diagramme zum Modellieren desdynamischen Verhaltens 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".
Einfügen von Kommunikationsdiagrammelementen
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Kommunikationsdiagramm-Symbolleiste auf das entsprechende
Kommunikationssymbol.
2. Klicken Sie in das Kommunikationsdiagramm, um das Element einzufügen.Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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önnendazu das Suchfunktionstextfeld verwenden oder Strg + F drücken, um nach einembeliebigen Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Kommunikationsdiagramm.
© 2010 Altova GmbH
Verhaltensdiagramme 211UML-Diagramme
Altova UModel 2010
LebenslinieDas Element "Lebenslinie" ist Teil einer Interaktion mehrerer Elemente. Sie haben in UModeldie Möglichkeit auch andere Elemente in das Kommunikationsdiagramm einzufügen, z.B.Klassen. Jedes dieser Elemente wird als neue Lebenslinie angezeigt. Sie können die Farben/Schattierung der Lebenslinie über die "Farbverlauf Titel"-Auswahllisten auf dem Register "Stile"neu definieren.
Zur Erstellung einer Lebenslinie mit mehreren Zeilen, drücken Sie Strg + Eingabetaste, 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.
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 ineiner Interaktion definiert. Bei einer Kommunikation kann es sich z.B. um das Auslösen einesSignals, den Aufruf einer Operation, das Erstellen oder Löschen einer Instanz handeln. DieNachricht definiert den Absender und Empfänger und um welche Art von Kommunikation essich 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.
212 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
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 von Kommunikationsdiagrammen: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ählenSie im Kontextmenü den Befehl Sequenzdiagramm generieren.
214 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.1.6 Interaktionsübersichtsdiagramm
Altova Website: UML-Interaktionsübersichtsdiagramme
Interaktinsü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übersichtsdiagramme werden auf ähnliche Art wie Aktivitätsdiagramme und unterVerwendung derselben Modellierungselemente (Start-/Endpunkte, Gabelungen, Vereinigungenusw.) erstellt.
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 vorhandeneInteraktionsdiagramme verweisen, wobei im Titelbereich des Rahmens das Schlüsselwort "Ref"und innerhalb des Rahmens der Name der Interaktionsinstanz angezeigt wird.
© 2010 Altova GmbH
Verhaltensdiagramme 215UML-Diagramme
Altova UModel 2010
Einfügen von Interaktionsübersichtselementen
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Interaktionsübersichtsdiagramm-Symbolleiste auf das entsprechende
Symbol
2. Klicken Sie in das Diagramm, um das Element einzufügen.Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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übersichtsdiagrammeingefü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, um nach einembeliebigen Element zu suchen).
2. Ziehen Sie das/die Element(e) in das Diagramm.
Einfügen eines Interaktionselements:1. Klicken Sie in der Symbolleiste auf das Symbol "Aufrufverhalten-Aktion (Interaktion)"
und anschließend in das Interaktionsübersichtsdiagramm, um es einzufügen.
Wenn Sie die Beispieldatei Bank_Multilanguage.ump aus dem Ordner ...\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.
216 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 dasInteraktionsübersichtsdiagramm, um das Element einzufügen.
Wenn Sie die Beispieldatei Bank_Multilanguage.ump aus dem Ordner ...\UModelExamples verwenden, wird das "Collect Account Information"
© 2010 Altova GmbH
Verhaltensdiagramme 217UML-Diagramme
Altova UModel 2010
Sequenzdiagramm automatisch als Interaktionselement eingefügt. Standardmäßigwird das erste in der Modell-Struktur gefundene Sequenzdiagramm ausgewählt
2. Um das Interaktionselement zu ändern, doppelklicken Sie auf dem Register"Eigenschaften" auf die Auswahlliste Verhalten.Daraufhin wird eine Liste aller Elemente angezeigt, die eingefügt werden können.
3. Wählen Sie das gewünschte Element aus.Beachten Sie, dass alle mit dieser Methode eingefügten Elemente wie in der 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 diesemKnoten nicht 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.
SynchronisationsknotenFügt einen vertikalen Synchronisationsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknoten
218 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
definierte Flüsse.
Synchronisationsknoten (horizontal)Fügt einen horizontalen Synchronisationsknoten ein.Ein Synchronisationsknoten synchronisiert mehrere durch den Parallelisierungsknotendefinierte Flü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 Uhrticksdarstellt, 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.
© 2010 Altova GmbH
Verhaltensdiagramme 219UML-Diagramme
Altova UModel 2010
10.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.
220 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Einfügen von Sequenzdiagrammelementen
In einem Sequenzdiagramm werden dynamische Laufzeit-Objektbeziehungen mit Hilfe vonNachrichten modelliert. Sequenzdiagramme dienen im Allgemeinen zur Verdeutlichungeinzelner Use Case-Szenarios.
Lebenslinien sind die horizontal angeordneten Kästchen am oberen Rand desDiagramms. Zusammen mit einer strichlierten vertikalen Linie stellen sie das Objektund seine Interaktionen in einem zeitlichen Ablauf dar. Nachrichten werden in Formvon Pfeilen zwischen den Lebenslininen von zwei oder mehr Objekten dargestellt.
Nachrichten werden zwischen sendenden und empfangenden Objekten gesendetund als Pfeile mit einer Bezeichnung dargestellt. Nachrichten können eineSequenznummer und verschiedene weitere optionale Attribute haben: argument listusw. Es werden bedingte, optionale und alternative Nachrichten unterstützt. NähereInformationen dazu finden 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.
© 2010 Altova GmbH
Verhaltensdiagramme 221UML-Diagramme
Altova UModel 2010
Über die Symbolleistensymbole:1. Klicken Sie in der Sequenzdiagrammsymbolleiste auf das jeweilige
Sequenzdiagrammsymbol.2. Klicken Sie in das Sequenzdiagramm, um das Element einzufügen.
Beachten Sie: Wenn Sie die Strig-Taste gedrückt halten, während Sie in dasDiagrammfenster klicken, können Sie mehrere Elemente des ausgewählten Typseinfügen.
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.
Lebenslinie
Lebenslinie Eine Lebenslinie ist als einzelnes Element an einer Interaktion beteiligt. Sie haben in UModeldie Mö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 Sequenzdiagramms
222 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
angezeigt. 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 aufdem Register "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ührungsspefizikation (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 benötigt wird, um etwaige geschachtelte Prozeduren auszuführen. Aktivierungskästchenwerden automatisch 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 zurLebenslinie hinzufü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
© 2010 Altova GmbH
Verhaltensdiagramme 223UML-Diagramme
Altova UModel 2010
geklickt haben. Das Element wird daraufhin im Fenster "Model-Struktur" angezeigt.
Combined Fragment
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.
Über die Symbole für Combinded Fragments in der Symbolleiste können Sie bestimmteCombined Fragments einfügen: seq, alt oder loop. Auch durch Klicken auf dieInteraktionsoperator-Auswahlliste können Sie das spezifische Interaktionsfragment definieren.
Interaktionsoperatoren
Lose Ordnung seq
224 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Das Combined Fragment stellt eine lose Ordnung zwischen dem Verhalten der Operanden dar.
Alternativen alt Nur einer der definierten Operanden wird ausgewählt. Der Operand muss eine "Guard-Expression" haben, deren Auswertung "true" ergibt.
Wenn in einem der Operanden der Guard-Ausdruck "else" verwendet wird, wird dieser Operandausgeführt, wenn alle anderen Guards den Wert "false" zurückgeben. Die Guard-Expressionkann unmittelbar beim Einfügen eingegeben werden und wird innerhalb der beiden eckigenKlammern angezeigt.
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 Operandendarstellt.
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.
© 2010 Altova GmbH
Verhaltensdiagramme 225UML-Diagramme
Altova UModel 2010
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 nichtdurch 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 Kombinationmit consider- oder ignore-Operanden verwendet.
Ignore ignoreDefiniert, welche Nachricht in der Interaktion ignoriert werden soll. Wird oft im Zusammenhangmit "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
Combined Fragment wird automatisch angepasst.
226 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Interaction Use
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.
Gate
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
Gate darstellt, wird nun kleiner angezeigt.
© 2010 Altova GmbH
Verhaltensdiagramme 227UML-Diagramme
Altova UModel 2010
Zustandsinvariante
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.
Nachrichten
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 nachunten angezeigt, 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. EinAufrufpfeil zeigt zum Anfang der Aktivierung, die der Aufruf initiiert. Rekursionen oder Aufrufe einer anderen Operation desselben Objekts werden durch
Übereinanderstapeln von Aktivierungskästchen angezeigt(Ausführungsspezifikationen).
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
228 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 denSender-/Empfänger-Objekten erstellt oder in der Größe angepasst. Sie können derenGröße auch manuell durch Ziehen der entsprechenden Ziehpunkte anpassen.
Abhängig davon, welche Einstellungen Sie für die Nummerierung der Nachrichtenaktiviert haben, wird die Nummerierungsreihenfolge aktualisiert.
Wenn Sie auf ein Nachrichtensymbol klicken und dabei die Strg-Taste gedrückthalten, können Sie mehrere Nachrichten einfügen. Ziehen Sie dazu einfach mehrereNachrichten in das Diagrammfenster.
So löschen Sie eine Nachricht:1. Klicken Sie auf die jeweilige Nachricht, um sie auszuwählen. 2. Drücken Sie die Entf-Taste, um die Nachricht aus dem Modell zu löschen oder
rechtsklicken Sie auf die Nachricht und wählen Sie den Befehl "Aus Diagrammlö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".
Die Anzeige ändert sich und die die Verbindungsoperation wird auf dem Register"Modell-Struktur" angezeigt.
© 2010 Altova GmbH
Verhaltensdiagramme 229UML-Diagramme
Altova UModel 2010
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 einerNachricht alle mit der aktiven in Zusammenhang stehenden Nachrichtenmitverschoben.
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 Nachrichtan einer beliebigen Stelle auf der vertikalen Achse zwischen den Objektlebenslinienpositionieren.
So erstellen Sie automatisch Antwortnachrichten:1. Klicken Sie auf die Schaltfläche "Automatische Erstellung von Anworten auf
Nachrichten (Call) ein/aus" .2. Erstellen Sie eine neue Nachricht zwischen den beiden Lebenslinien. Daraufhin wird
automatisch eine Antwortnachricht eingefügt.
Nachrichtennummerierung:UModel unterstützt verschiedene Methoden der Nachrichtennummerierung: hierarchisch,einfach und keine.
230 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Keine entfernt alle Nachrichtennummern.
Einfach nummeriert alle Nachrichten von oben nach unten, also in derReihenfolge, in der sie auf der Zeitachse vorkommen, durch.
Hierarchisch verwendet eine Dezimaldarstellung, sodass die hierarchischeStruktur der Nachrichten im Diagramm deutlich wird. Die Hierarchie wird in Form einerdurch Punkte getrennten Nummerierung, gefolgt von einem Doppelpunkt und demNamen der Nachricht dargestellt.
So wählen Sie die Art der Nachrichtennummerierung aus:Es gibt zwei Methoden, um das Nummerierungssystem auszuwählen:
Klicken Sie auf das jeweilige Symbol in der Symbolleiste. Wählen Sie das Nummerierungssystem über das Register "Stile" aus.
Um das Nummerierungssystem über das Register "Stile" auszuwählen:1. Klicken Sie auf das Register "Stile" und scrollen Sie hinunter zum Feld
Nachrichtennummern.2. Klicken Sie auf das Auswahllistenfeld und wählen Sie die gewünschte
Nummerierungsoption aus.Die gewählte Nummerierungsoption wird sofort im Sequenzdiagramm angezeigt.
Bitte beachten Sie:Bei Vorhandensein nicht eindeutiger Spuren werden mit dem gewähltenNummerierungssystem 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. WennAktivierungskästchen deaktiviert wurden (Register "Stile" | Show Execution Specifics=false),sollten aus Gründen der Übersichtlichkeit Pfeile verwendet werden.
Wenn Sie die Schaltfläche "Automatische Erstellung von Anworten auf Nachrichten (Call)
ein/aus" aktivieren, wird automatisch eine syntaktisch korrekte Antwortnachricht erstellt, wenn Sieeine Call-Nachricht zwischen Lebenslinien/Aktivierungskästen erstellen.
© 2010 Altova GmbH
Verhaltensdiagramme 231UML-Diagramme
Altova UModel 2010
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 derAutokomplettierungsfunktionen eine Nachricht von einer Lebenslinie zu einer bestimmtenMethode 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-Fenstermit 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.
232 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
Nachrichtensymbole:
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 Anworten auf Nachrichten (Call) ein/aus
Generieren von Sequenzdiagrammen anhand von Quellcode
Sie können in UModel nun Sequenzdiagramme direkt anhand von Code erstellen. .
Im Beispiel unten sehen Sie, wie man automatisch ein Sequenzdiagramm unter Verwendungeiner bestehenden Methode erstellt. Sie können auf diese Weise natürlich auch anhand Ihres
© 2010 Altova GmbH
Verhaltensdiagramme 233UML-Diagramme
Altova UModel 2010
eigenen 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..."
Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung", angezeigt, in dem Siedie Einstellungen dazu definieren können.
234 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
Mit der Option "Anmerkungen auf separater Ebene hinzufügen" werden dieCodeanmerkungen der Ebene "Code-Annotationen" zugewiesen. DieCodeanmerkungen werden orange angezeigt.
Anmerkungen: Sie können nicht anzeigbaren Aufrufen eine spezielle Farbe zuweisen.
© 2010 Altova GmbH
Verhaltensdiagramme 235UML-Diagramme
Altova UModel 2010
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 einekommagetrennte Liste von Operationen definieren, die im generiertenSequenzdiagramm nicht aufscheinen sollen (initComponents werden standardmäßigautomatisch 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-Projektaktualisieren. 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 Eigenschaften
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 generieren.Daraufhin wird das Dialogfeld Wählen Sie eine oder mehrere Operationen ausgeöffnet.
236 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
2. Wählen Sie die Operationen aus, für die Sie ein Sequenzdiagramm generierenmö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 Sequenzdiagrammendefinieren können.
3. Klicken Sie auf OK, um die Sequenzdiagramme zu generieren.Für jede der ausgewählten Operationen wird ein Sequenzdiagramm generiert.
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.
© 2010 Altova GmbH
Verhaltensdiagramme 237UML-Diagramme
Altova UModel 2010
2. Wählen Sie im Kontextmenü die Option aus, mit der das gewünschteSequenzdiagramm generiert werden soll (Getter/Setter).Daraufhin wird das Dialogfeld "Sequenzdiagrammgenerierung" geöffnet, in dem Sie dieEigenschaften für die Darstellung des Sequenzdiagramms einstellen können.
3. Klicken Sie auf OK, um das Sequenzdiagramm zu generieren.
238 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.1.8 Zeitverlaufsdiagramm
Altova Website: UML-Zeitverlaufsdiagramme
Zeitverlaufsdiagramme dienen zum Darstellen von Änderungen am Status oder Zustand voneinem oder mehreren miteinander in Wechselbeziehung stehenden Objekten über einenbestimmten Zeitraum. Zustände werden in Form von Zeitlinien dargestellt, die auf MessageEvents reagieren, wobei eine Lebenslinie eine Classifier Instance oder Classifier Role darstellt.
Bei Zeitverlaufsdigrammen 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-Zeitline, die andere allgemeinere Art enthält, wie unten gezeigt, eineLebenslinie.
© 2010 Altova GmbH
Verhaltensdiagramme 239UML-Diagramme
Altova UModel 2010
Einfügen von Elementen des Zeitverlaufsdiagramms
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.Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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.
Lebenslinie
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.
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.
240 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 aufeiner Linie 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:1. Klicken Sie auf den Zustand und drücken Sie die Entf-Taste oder klicken Sie auf die
rechte Maustaste und wählen Sie den Befehl "Löschen".
So wechseln Sie zwischen Zeitverlaufsdiagrammtypen:1. Klicken Sie auf das Symbol "Darstellung wechseln" rechts unterhalb der Lebenslinie.
Daraufhin wird stattdessen eine Wertverlaufslebenslinie angezeigt, der Kreuzungspunktstellt eine Änderung eines Zustands/Werts dar.
© 2010 Altova GmbH
Verhaltensdiagramme 241UML-Diagramme
Altova UModel 2010
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 Lebenslinine 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.
Tick-Symbol
Tick-SymbolDieses Symbol dient zum Einfügen der Tick-Symbole eines Zeitverlaufslineals auf einerLebenslinie.
So fügen Sie ein Tick-Symbol ein:
242 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
1. Klicken Sie auf das Tick-Symbol in der Symbolleiste und anschließend auf dieLebenslinie, um es einzufügen.
2. Um mehrere Tick-Symbole einzufügen, halten Sie die Strg-Taste gedrückt, währendSie auf verschiedene Positionen am Rand der Lebenslinie klicken.
3. Geben Sie in das dafür vorgesehene Feld eine Beschriftung für das Tick-Symbol ein.Zum Neupositionieren der Tick-Symbole auf der Lebenslinie ziehen Sie die Symbolemit der Maus an die gewünschte Stelle.
So ordnen Sie die Tick-Symbole in gleichmäßigen Abständen auf einer Lebenslinie an:1. Ziehen Sie im Hauptfenster ein Rechteck auf, um die einzelnen Tick-Symbole zu
markieren.
2. Klicken Sie in der Symbolleiste auf das Symbol Waagrecht anordnen .
Auslösendes Ereignis
Auslösendes EreignisDas ExecutionEvent "Auslösendes Ereignis" dient dazu, eine Änderung im Zustand einesObjekts anzuzeigen, 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".
© 2010 Altova GmbH
Verhaltensdiagramme 243UML-Diagramme
Altova UModel 2010
Beachten Sie, dass die Eigenschaften des Ereignisses auf dem Register"Eigenschaften" angezeigt werden.
Zeitdauerbedingung
ZeitdauerbedingungEine Zeitdauer definiert eine Wertespezifikation zur Angabe einer Zeitdauer zwischen einemStart- und einem Endpunkt. Eine Zeitdauer ist oft ein Ausdruck zur Darstellung der Ticks derUhr, die während dieser Zeitdauer verstreichen.
So fügen Sie eine Zeitdauerbedingung ein:1. Klicken Sie auf das Symbol "Zeitdauerbedingung" und anschließend auf die Stelle auf
der Lebenslinie, an der die Bedingung angezeigt werden soll.
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.
Zeitbedingung
244 UML-Diagramme Verhaltensdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
Die Standard-Minimum- und Maximum-Werte "d..t" werden automatisch vorgegeben.Durch Doppelklick auf die Zeitbedingung oder durch Bearbeitung der Werte im Fenster"Eigenschaften" können Sie diese Werte bearbeiten.
Nachricht
Message (Aufruf) Nachricht (Antwort) Asynchrone Nachricht (Aufruf)
Eine Nachricht ist ein Modellierungselement, das eine bestimmte Art von Kommunikation ineiner Interaktion definiert. Dabei kann es sich z.B. um das Auslösen eines Signals, den Aufrufeiner Operation, das Erstellen oder Löschen einer Instanz handeln. Die Nachricht definiert dieArt der durch die absendende Ausführungsspezifikation definierten Kommunikation sowie denAbsender und den Empfänger.
Nachrichten werden zwischen sendenden und empfangenden Zeitlinien gesendet und werdenals beschriftete 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.
© 2010 Altova GmbH
Verhaltensdiagramme 245UML-Diagramme
Altova UModel 2010
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.
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".
246 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.2 Strukturdiagramme
Diese Diagramme dienen zur Darstellung der Strukturelemente, aus denen ein System odereine Funktion 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
© 2010 Altova GmbH
Strukturdiagramme 247UML-Diagramme
Altova UModel 2010
10.2.1 Klassendiagramm
Eine Anleitung zum Hinzufügen von Klassen zum Diagramm finden Sie im Tutorial im Abschnitt Klassendiagramme.
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 jeweiligenBereich zu erweitern/auszublenden.
Ziehen Sie ein Rechteck (über dem Diagrammhintergrund) auf, um mehrere Klassenzu markieren und klicken Sie anschließend die Schaltfläche "Erweitern/Ausblenden".Sie können mehrere Klassen auch mit Hilfe von Strg+Klick auswählen.
Drücken Sie Strg + A, um alle Klassen auszuwählen. Klicken Sie anschließend in 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 zuerweitern
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önnen auch ä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..
248 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
Sie können wählen zwischen dem oben gezeigten UModel Typ und den untengezeigten UML-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 Elementehinzufü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.
© 2010 Altova GmbH
Strukturdiagramme 249UML-Diagramme
Altova UModel 2010
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 Dialogfeldgeöffnet.
Beachten Sie: Einzelne Attribute können davon betroffen sein, wenn Sie nur dasKontrollkästchen im 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 jedeeinzelne dieser "Ansichten" der Klasse separat definiert werden. In der Abbildung unten sehenSie zwei Ansichten derselben Klasse, nämlich SavingsAccount.
Mit Hilfe der Option "Beim Hinzufügen neuer Elemente, die nicht durch Elementstileausgeblendet werden" können Sie festlegen, was sichtbar gemacht werden soll, wenn neueElemente zur Klasse hinzugefügt werden. Elemente können manuell oder automatisch währendder Codegenerierung 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 SavingsAccount
250 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
ausgeblendet, 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.
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.
© 2010 Altova GmbH
Strukturdiagramme 251UML-Diagramme
Altova UModel 2010
Wenn Sie auf die linke Klasse klicken und F7 drücken (oder in der Modellstruktur auf dieKlasse klicken und F7 drücken), wird ein neues Attribut (Property1) zur Klasse hinzugefügt.
Das neue Element ist nur in der linken Klasse sichtbar, da hier die Option "Elemente anzeigen"aktiv ist. In der rechten Klasse ist die Option "Elemente ausblenden..." aktiv, sodass das 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.
252 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 Siedie Option "Ausblenden" auswählen.
Ä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.
So ändern Sie die Standardeinstellung für die Syntaxfarben (siehen 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.
© 2010 Altova GmbH
Strukturdiagramme 253UML-Diagramme
Altova UModel 2010
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.
Außer Kraft Setzen von Basisklassenoperationen und Implementieren vonSchnittstellenoperationenSie 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 oben gezeigte Dialogfeld "Überschriebene Methoden" geöffnet.
254 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
2. Wählen sie die Operationen aus, die Sie außer Kraft setzen möchten und bestätigenSie mit 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 undimplementierten Schnittstellen, die dieselbe Signatur wie bestehende Operationenhaben, automatisch ausgewählt, d.h. aktiviert.
Erstellen von Getter / Setter-MethodenWährend des Modellierens müssen oft get/set-Methoden für bestehende Attribute erstelltwerden. UModel bietet für diesen Zweck zwei separate Methoden:
Verschieben eines Attributs mit Hilfe von Drag and Drop in den Operation-Bereich Verwendung des Kontextmenüs zum Öffnen eines Dialogfelds, in dem Sie die get/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.
© 2010 Altova GmbH
Strukturdiagramme 255UML-Diagramme
Altova UModel 2010
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.
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 oderklicken Sie auf die Kontrollkästchen der einzelnen Methoden.
256 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
Bitte beachten Sie:Sie können auch auf ein einzelnes Attribut rechtsklicken und auf dieselbe Art eineOperation dafür erstellen.
Ball-and-socket NotationUModel 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.
Hinzufügen von Ausnahmeereignissen zu Methoden einer Klasse1. Klicken Sie im Fenster "Modellstruktur" auf die Methode der Klasse, zu der Sie das
Ausnahmeereignis hinzufügen möchten, z.B. in der Klasse "Account" auf getBalance.2. Rechtsklicken Sie in das Fenster "Eigenschaften" und wählen Sie im Popup-Menü den
Befehl Ausnahmeereignis hinzufügen.
© 2010 Altova GmbH
Strukturdiagramme 257UML-Diagramme
Altova UModel 2010
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 dasFeld ein.
258 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.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.
Einfügen von Elementen eines Kompositionsstrukturdiagramms
Über die Schaltflächen der Symbolleiste:1. Klicken Sie in der Symbolleiste auf das jeweilige Kompositionsstrukturdiagramm-
Symbol.2. Klicken Sie in das Kompositionsstrukturdiagramm, um das Element einzufügen.
Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und auf das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
Ziehen bestehender Elemente in das Kompositionsstrukturdiagramm:Die meisten Elemente, die in anderen Kompositionsstrukturdiagrammen vorkommen, können inein bestehendes Kompositionsstrukturdiagramm eingefügt werden.
© 2010 Altova GmbH
Strukturdiagramme 259UML-Diagramme
Altova UModel 2010
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.
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 Namender Instanz, 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 dieZielkollaboration muss mindestens einen Part/eine Rolle haben.
Part (Eigenschaft)Fügt ein Part-Element ein, das eine Gruppe von einer oder mehreren Instanzen darstellt, die 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)
260 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
Fügt das Abhängigkeitselement ein. Dieses Element zeigt an, welches verbindbare Elementdes Classifiers oder der Operation welche Rolle in der Kollaboration spielt.
© 2010 Altova GmbH
Strukturdiagramme 261UML-Diagramme
Altova UModel 2010
10.2.3 Komponentendiagramm
Eine Anleitung zum Hinzufügen von Komponentenelementen zum Diagramm finden Sie imTutorial im Abschnitt Komponentendiagramme.
262 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.2.4 Deployment-Diagramm
Eine Anleitung zum Hinzufügen von Knoten und Artefakten zum Diagramm finden Sie imTutorial im Abschnitt Deployment-Diagramme.
© 2010 Altova GmbH
Strukturdiagramme 263UML-Diagramme
Altova UModel 2010
10.2.5 Objektdiagramm
Eine Anleitung zum Hinzufügen neuer Objekte/Instanzen zum Diagramm finden Sie im Tutorialim Abschnitt Objektdiagramme section in the tutorial for more information on how to add newobjects/instances to the diagram.
264 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
10.2.6 Paketdiagramm
In Pakediagrammen werden die Struktur von Paketen und ihren Elementen sowie dieentsprechenden Namespaces angezeigt. Zusätzlich dazu können Sie in UModel einenHyperlink erstellen 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.
Automatische Generierung von PaketabhängigkeitenUModel bietet die Möglichkeit, ein Paketabhängigkeitsdiagramm für jedes beliebige Paket in derModell-Struktur 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.
© 2010 Altova GmbH
Strukturdiagramme 265UML-Diagramme
Altova UModel 2010
2. Wählen Sie die gewünschten Optionen aus und klicken Sie zur Bestätigung auf OK.
Es wird ein neues Diagramm generiert, in dem die Paketabhängigkeiten des Pakets"altova" angezeigt werden.
Einfügen von Paketdiagrammelementen
Verwendung der Symbolleisten-Schaltflächen:1. Klicken Sie in der Paketdiagramm-Symbolleiste auf das entsprechende Symbol.
2. Klicken Sie in das Diagramm, um das Element einzufügen. Beachten Sie: Wenn Sie die Strg-Taste gedrückt halten und in das Diagrammregisterklicken, können Sie mehrere Elemente des ausgewählten Typs einfügen.
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
266 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
und zur Bereitstellung eines Namespace für die gruppierten Elemente. Da es sich bei einemPaket um einen Namespace handelt, kann ein Paket einzelne Elemente oder alle Elementeanderer Pakete importieren. Pakete können auch mit anderen Paketen zusammengeführtwerden.
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äreErweiterungskonstrukt ist das Stereotyp, welches selbst Teil des Profils ist. Profile müssenimmer in Beziehung zu einem Referenz-Metamodell wie z.B. UML stehen und können nichtalleine 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 inkludiertenPakets in das inkludierende Paket importiert werden. Der Namespace des inkludierendenPakets erhält Zugriff auf den inkludierten Namespace; der Namespace des inkludierten Paketsist nicht betroffen.
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 Quellpaketgekennzeichnet.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.
© 2010 Altova GmbH
Strukturdiagramme 267UML-Diagramme
Altova UModel 2010
10.2.7 Profildiagramm und Stereotype
Altova Website: UML-Profildiagramme
In UML-Profldiagrammen 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 | Unterprojektinkludieren muss die Datei Java Profile.ump (C# Profile.ump oder VB Profile.ump)angewendet werden. Dieses Profil liefert die Java-Datentypen und Stereotype und wird für dieErstellung von Code für das Round-Trip Engineering benötigt.
In den folgenden Abschnitten werden folgende Punkte beschrieben: Hinzufügen von Stereotypen und Definieren von Eigenschaftswerten Stereotype und Enumerationen Benutzerdefinierte Stereotypstile
In der Datei Bank_CSharp.ump (im Ordner ...\UModelExamples) sehen Sie ein Beispiel dafür.Das C#-Profil wurde auf das Paket "BankView" angewendet.
Profile sind bestimmte Arten von Paketen, die auf andere Pakete angewendetwerden. Stereotype sind bestimmte Metaklassen, die Standardklassen erweitern. "Eigenschaftswerte" sind Werte von Stereotypattributen.
268 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
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 Klassendiagrammendargestellt und werden zusätzlich mit dem Schlüsselwort <<stereotype>> oberhalb desKlassennamens versehen.
Stereotype können Eigenschaften haben, die als "Eigenschaftsdefinition"bezeichnet werden. Wenn das Stereotyp auf ein Modellelement angewendet wird, werden die Werte der
Eigenschaften als "Eigenschaftswerte" bezeichnet. Bei Anwendung von Steretypen, die Eigenschaften enthalten, werden die
Eigenschaftswerte automatisch in einem Comment-Element (siehe unten) angezeigt.Nähere Informationen zum Anpassen der Eigenschaftswerteansicht finden Sie unter Eigenschaftswerte. Stereotype haben Ihre eigene Stilfamilie. Wenn das Attribut vom Typ "Enumeration" ist, erscheint ein Popup-Menü, aus dem
Sie einen der vordefinierten Werte auswählen können. Sie können auch denjeweiligen Wert auf dem Register "Eigenschaften" eingeben/auswählen, z.B.<<GetAccessor>> Sichtbarkeit = public, protected usw.
© 2010 Altova GmbH
Strukturdiagramme 269UML-Diagramme
Altova UModel 2010
Hinzufügen von Stereotypen und Definieren von Eigenschaftswerten
In diesem Abschnitt wird die Datei Bank_MultiLanguage.ump aus dem Ordner ...\UModelExamples verwendet.
Erstellen eines Profildiagramms und eines 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 |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 neue
270 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
Klassendiagramm.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.
© 2010 Altova GmbH
Strukturdiagramme 271UML-Diagramme
Altova UModel 2010
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 Attributhinzuzufügen.
3. Mit Hilfe der Bildlaufleiste des Registers "Eigenschaften" können Sie zum unterenBereich der Liste scrollen. Beachten Sie, dass das Stereotyp MyKeyValuePair imListenfeld zur Verfügung steht.
4. Klicken Sie auf das Kontrollkästchen von MyKeyValuePair um das Stereotyp zuaktivieren/anzuwenden. Die beiden Eigenschaftswerte MyKey1 und MyKey2 werden
272 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
nun unter 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 Anmerkungselementangezeigt. Wenn Sie im Anmerkungselement auf einen Wert doppelklicken, können Sieihn direkt bearbeiten.
Eigenschaftswerte anzeigen: in Bereich
© 2010 Altova GmbH
Strukturdiagramme 273UML-Diagramme
Altova UModel 2010
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 Anzeigevon Eigenschaftswerten.
Stereotype und Enumerationen
UModel verfügt über eine effiziente Methode zum Auswählen von Enumerationswerten vonStereotypen.
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 undNo.
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.
274 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
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.
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.
© 2010 Altova GmbH
Strukturdiagramme 275UML-Diagramme
Altova UModel 2010
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 Stereotypstile
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
Klassendiagramm. 2. Aktivieren Sie das Register "Stile" und wählen Sie anschließend in der Auswahlliste die
Option Stile von Elementen mit diesem Stereotyp aus.3. Definieren Sie die Stile für dieses Stereotyp mit Hilfe der Optionen auf dem Register
"Stile", z.B. Farbverlauf Titel Ende = Aquamarin.
Wenn Sie auf die Stereotypklasse klicken, werden die Stereotypstile automatisch auf
276 UML-Diagramme Strukturdiagramme
© 2010 Altova GmbHAltova UModel 2010
dem Register "Stile" angezeigt.4. Wechseln Sie zu einem anderen Klassendiagramm und fügen Sie einen neue Klasse
ein.5. Klicken Sie auf die Überschrift/den Titel der Klasse und aktivieren Sie das 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.
Sie können nun eine Vorschau der für dieses Stereotyp definierten Stileeinstellungenim Fenster "Stile" anzeigen. Beachten Sie, dass Sie die Stileeinstellungen hier nichtändern können. Dies muss in dem Klassendiagramm erfolgen, in dem das Stereotypdefiniert wurde.
© 2010 Altova GmbH
Zusätzliche Diagramme 277UML-Diagramme
Altova UModel 2010
10.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.
UModel unterstützt nun den Business Processing Modeling Standard Version 1.0, der imFebruar 2006 als OMG-Standard veröffentlicht wurde.
XML-Schema
278 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
10.3.1 XML-Schema-Diagramme
Altova Website: XML-Schemas in UML
In XML-Schema-Diagrammen werden Schemakomponenten in UML-Notation dargestellt.Globale Elemente, d.h. Elemente, simpleTypes, complexTypes werden als Klassen oderDatentypen mit den Attributen im Attributbereich angezeigt. Es gibt keine Operationen imOperationen-Bereich. Zur Anzeige der Schemainformationen wird das Eigenschaftswert-NotizModellierungselement verwendet.
Eine Tabelle über die Entsprechungen zwischen UML-Elementen und XML-Schema-Elementen/Attributen finden Sie unter XML Schema von/zu UModel Elementen.
Bitte beachten Sie:Ungültige XML-Schemas können nicht in UModel importiert werden. XML-Schemaswerden beim Import oder bei der Erstellung in UModel nicht validiert. XML-Schemaswerden bei der Überprüfung der Projektsyntax nicht berücksichtigt. Beim Import einesXML-Schemas wird jedoch die Wohlgeformtheit des Schemas überprüft.
© 2010 Altova GmbH
Zusätzliche Diagramme 279UML-Diagramme
Altova UModel 2010
Importieren von XML-Schemas
So importieren Sie ein einzelnes XML-Schema:1. Wählen Sie die Menüoption Projekt | XML-Schema-Datei importieren.
2. Stellen Sie sicher, dass das Kontrollkästchen Diagrammgenerierung aktivierenaktiviert ist und klicken Sie zum Fortfahren auf "Weiter".
3. Definieren Sie die Inhaltsdiagrammoptionen in der Gruppe, die diese Überschrift trägt.Mit der ersten Option wird für jedes globale Schema-Element ein separates Diagrammerstellt.
4. Wählen sie die Bereiche aus, die in der Gruppe "Stile" in Klassendiagrammenangezeigt werden sollen. Bei Auswahl der Option " Schemainformationen alsEigenschaftswerte angzeigen" werden die Schemainformationen im Eigenschaftswert-
280 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
Notiz-Modellierungselement angezeigt.5. Klicken Sie auf "Weiter", um das Pakektabhä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.
© 2010 Altova GmbH
Zusätzliche Diagramme 281UML-Diagramme
Altova UModel 2010
Bitte beachten Sie:Es wurde ein neues Paket mit dem Namen "Alle Schemas" erstellt und als XSD NamespaceRoot definiert. Anhand aller XSD Globals wird ein XML-Schema-Diagramm generiert, wobei dieDiagramme unter den jeweiligen Namespace-Paketen angelegt werden.
So importieren Sie mehrere XML-Schemas:1. Wählen Sie die Menüoption Projekt | XML-Schemaverzeichnis importieren.
282 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
2. Aktivieren Sie die Option "Alle Unterverzeichnisse verarbeiten", wenn auch Schemasaus allen Unterverzeichnissen importiert werden sollen.Der restliche Importvorgang erfolgt wie beim Import eines einzelnen XML-Schemas(Beschreibung siehe oben).
Bitte beachten Sie:Wenn ein XML-Schema andere Schemas inkludiert oder importiert, werden auch 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 untenin der Eigenschaftswert-Anmerkung konfiguriert werden. Hier können Sie zwischen den beidenunten gezeigten Modi "Alle" und "Alle, leere ausblenden" wechseln.
Anmerkung: Wenn Sie die Eigenschaftswerte vom Register Stile auswählen, werden die Einstellungen fürdie Eigenschaftswerte projektweit vorgenommen. Wenn Sie mit der rechten Maustaste auf eine
© 2010 Altova GmbH
Zusätzliche Diagramme 283UML-Diagramme
Altova UModel 2010
Klasse klicken und Eigenschaftswerte | alle usw. auswählen, so wirkt sich die Einstellung nurauf die einzeln markierten Klassen aus.
Eigenschaftswerte anzeigen: AlleZeigt die Eigenschaftswerte der Klasse sowie jene der dazugehörigen Attribute, Operationenusw. an.
Eigenschaftswerte anzeigen: Alle, leere ausblendenZeigt 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.
284 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
Eigenschaftswerte anzeigen: Element, leere ausblendenZeigt nur die Eigenschaftswerte einer Klasse an, jedoch ohne die dazugehörigen Attribute, fürdie ein Wert vorhanden ist, z.B. id=123
Eigenschaftswerte anzeigen: im Bereich
Zeigt die Eigenschaftswerte in einem separaten Klassenbereich an.
Eigenschaftswerte anzeigen: in Bereich, leere 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 einescomplex- oder simpleType im Fenster "Dokumentation" angezeigt wird.
© 2010 Altova GmbH
Zusätzliche Diagramme 285UML-Diagramme
Altova UModel 2010
Einfügen von XML-Schema-Elementen
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 Diagrammregisterklicken, 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 bestehendesXML-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.
XSD Target NamespaceFügt den Target Namespace für das Schema ein oder definiert ihn. Der XSD TargetNamespace muss 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.
286 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
So definieren Sie die Datentyp-Eigenschaft:1. Doppelklicken Sie auf die Eigenschaft und platzieren Sie den Cursor am Ende der Zeile.2. Geben Sie einen Doppelpunkt ":" ein und wählen Sie im Popup-Dialogfeld den Datentyp aus,z.B. String.
Erstellen eines "Content Model", das aus einem complexTyp mit obligatorischenElementen 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".
© 2010 Altova GmbH
Zusätzliche Diagramme 287UML-Diagramme
Altova UModel 2010
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.
288 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Zusätzliche Diagramme 289UML-Diagramme
Altova UModel 2010
Erstellen und Generieren eines XML-Schemas
Im Allgemeinen wird ein Schema importiert, in UModel bearbeitet und anschließend werden dieÄnderungen ausgegeben. Sie können ein Schema aber auch von Grund auf neu erstellen. 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 änder Sie es in den gewünschten
Namespace, z.B. http://www.my-ns.com.6. Klicken Sei auf dem Register "Eigenschaften" auf das Kontrollkästchen
<<namespace>>, um diesen als den Target Namespace zu definieren.
7. Rechtsklicken Sie auf das Namespace-Paket und wählen Sie den Befehl 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.
290 UML-Diagramme Zusätzliche Diagramme
© 2010 Altova GmbHAltova UModel 2010
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.
292 Austausch von Metadaten zwischen XMI und XML
© 2010 Altova GmbHAltova UModel 2010
11 Austausch von Metadaten zwischen XMI und XML
Altova Website: Austausch von UModel-Projekten über XMI
UModel unterstützt den Export und Import von XMI 2.1.1 für UML 2.0 / 2.1 / 2.1.1 und 2.1.2, 2.2,2.3. 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 meistenUML-Tools unterstützt. UModel exportiert standardmäßig diese ID-Typen, d.h. keinesder Kontrollkästchen muss aktiviert werden.
UUID sind Universally Unique Identifiers und bieten eine Methode, um jedemElement eine GUID (Global Unique Identification) zuzuweisen, d.h. UUIDs sind nichtauf bestimmte XMI-Dokumente beschränkt. UUIDs werden durch Auswahl desKontrollkästchens "UUIDs exportieren" generiert.
UUIDs werden im Standardformat UUID/GUID gespeichert (z.B."6B29FC40-CA47-1067-B31D-00DD010662DA", "550e8400-e29b-41d4-a716-446655440000",...)
© 2010 Altova GmbH
293Austausch von Metadaten zwischen XMI und XML
Altova UModel 2010
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 derUML-Spezifikation und müssen daher in XMI gelöscht oder unter "Extensions" gespeichertwerden. Wenn sie als Erweiterungen exportiert wurden und wieder importiert werden, werdenalle Dateinamen 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.
296 Versionskontrolle
© 2010 Altova GmbHAltova UModel 2010
12 Versionskontrolle
Altova hat in UModel Microsoft Source Code Control Interface (MSSCCI) v1.1 – v1.3implementiert, sodass UModel nun Microsoft Source-Safe und andere kompatibleSpeicherschnittstellen unterstützt. Altova hat die Funktionen mit einer ganzen Reihe vonTreibern und Versionskontrollsystemen getestet; eine Liste davon finden Sie im Abschnitt Unterstützte Versionskontrollsysteme.
Bitte beachten Sie:Die 64-Bit Version von UModel unterstützt automatisch alle der in dieserDokumentation angeführten unterstützten 32-Bit-Versionskontrollprogramme.
Bei Verwendung einer 64-Bit-Version von UModel mit einem32-Bit-Versionskontrollprogramm ist die Option "Statusaktualisierungen alle ...msdurchführen" (Extras | Optionen) automatisch ausgegraut und kann nicht ausgewähltwerden.
Registry-Eintrag und Plug-insMicrosoft hat einen Registry-Eintrag definiert, bei dem alle SCC-kompatiblen Programme sichselbst registrieren. Dies ist der Eintrag fürUModel.
HKEY_LOCAL_MACHINE\SOFTWARE\SourceCodeControlProvider\InstalledSCCProviders
Bitte beachten Sie außerdem, dass Plugins für Versionskontrollsysteme nicht von allenSSC-Produkten automatisch installiert werden. Nähere Informationen finden Sie in derDokumentation zu Ihrer Versionskontrollsoftware.
Aufrufen von Versionskontrollbefehlen in UModel
Versionskontrollbefehle können auf die folgenden Arten aufgerufen werden:
Über den Menübefehl Projekt | Versionskontrolle
Über das Kontextmenü im Projektfenster
Ein Versionskontrollprojekt ist jedoch nicht dasselbe wie ein Authentic DesktopUModell-Projekt.Versionskontrollprojekte sind verzeichnisabhängig, während UModel-Projekte logischeKonstruktionen ohne Verzeichnisabhängigkeit sind.
Die Visual Studio und die Eclipse Version von UModel unterstützen nun dieVersionskontrollfunktionen und Menübefehle, die in der jeweiligen IDE zur Verfügung stehen.
In diesem AbschnittDieser Abschnitt ist folgendermaßen gegliedert:
Unterstützte Versionskontrollsysteme enthält eine Liste der Versionskontrollsysteme(SCS), die von UModel unterstützt werden. Die Systeme werden in alphabetischerReihenfolge nach Server aufgelistet. Für jeden Server werden auch die unterstütztenClients aufgelistet.
Installieren von Versionskontrollsystemen enthält Anmerkungen, wie die verschiedenenVersionskontrollsysteme installiert werden.
© 2010 Altova GmbH
297Versionskontrolle
Altova UModel 2010
Versionskontrollsyteme SCSs und Vergleich mit Altova DiffDog enthält eineBeschreibung, wie die verschiedenen Versionskontrollsysteme für das Vergleichen mitAltova DiffDog konfiguriert werden .
Versionskontrollbefehle enthält eine Beschreibung zu jedem einzelnen Befehl imUntermenü Projekt | Versionskontrolle.
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 im Hintergrund alle xxx Sek." zudeaktivieren oder das Aktualisierungsintervall zu vergrößern.
298 Versionskontrolle Unterstützte Versionskontrollsysteme
© 2010 Altova GmbHAltova UModel 2010
12.1 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. In den Anmerkungen im Anschluss an dieListe finden Sie Informationen über den Grad der Unterstützung.
AccuRev
Version: AccuRev 4.7.0 Windows
Clients: AccuBridge for Microsoft SCC 2008.2
Bazaar
Version: Bazaar 1.9 Windows
Clients: Aigenta Unified SCC 1.0.6
Borland StarTeam 2008
Version: StarTeam 2008 Release 2
Clients: Borland StarTeam Cross-Platform Client 2008 R2
Codice Software Plastic SCM
Version: Codice Software Plastic SCM Professional 2.7.127.10 (Server)
Clients: Codice Software Plastic SCM Professional 2.7.127.10 (SCC Plugin)
Collabnet Subversion 1.5
Version: 1.5.4
Clients: Aigenta Unified SCC 1.0.6 PushOK SVN SCC 1.5.1.1 <%AC-PUSHOKSVNX64%> TamTam SVN SCC 1.2.21
ComponentSoftware CS-RCS (PRO)
Version: ComponentSoftware CS-RCS (PRO) 5.1
Clients: ComponentSoftware CS-RCS (PRO) 5.1
Dynamsoft SourceAnywhere for VSS
© 2010 Altova GmbH
Unterstützte Versionskontrollsysteme 299Versionskontrolle
Altova UModel 2010
Version: Dynamsoft SourceAnywhere for VSS 5.3.2 Standard/Professional Server
Clients: Dynamsoft SourceAnywhere for VSS 5.3.2 Client
Dynamsoft SourceAnywhere Hosted
Version: Server hosted in a Bell Data Center
Clients: Dynamsoft SourceAnywhere Hosted Client (22252)
Dynamsoft SourceAnywhere Standalone
Version: SourceAnywhere Standalone 2.2 Server
Clients: Dynamsoft SourceAnywhere Standalone 2.2 Client
IBM Rational ClearCase 7
Version: 7.0.1 (LT)
Clients: IBM Rational ClearCase 7.0.1 (LT)
March-Hare CVSNT 2.5
Version: 2.5.03.2382
Clients: Aigenta Unified SCC 1.0.6
March-Hare CVS Suite 2008
Version: Server 2008 [3321]
Clients: Jalindi Igloo 1.0.3 March-Hare CVS Suite Client 2008 (3321) PushOK CVS SCC NT 2.1.2.5 <%AC-PUSHOKCVSX64%> TamTam CVS SCC 1.2.36
Mercurial
Version: Mercurial 1.0.2 for Windows
Clients: Sergey Antonovs HgSCC 1.0.1
Microsoft SourceSafe 2005
300 Versionskontrolle Unterstützte Versionskontrollsysteme
© 2010 Altova GmbHAltova UModel 2010
Version: 2005 with CTP
Clients: Microsoft SourceSafe 2005 with CTP
Microsoft Visual Studio Team System 2008 Team Foundation Server
Version: 2008
Clients: Microsoft Team Foundation Server 2008 MSSCCI Provider
Perforce 2008
Version: P4S 2008.1
Clients: Perforce P4V 2008.1
PureCM
Version: PureCM Server 2008/3a
Clients: PureCM Client 2008/3a
QSC Team Coherence Version Manager
Version: QSC Team Coherence Server 7.2.0.30
Clients: QSC Team Coherence Client 7.1.4.30
Qumasoft QVCS Enterprise
Version: QVCS Enterprise 2.1.18
Clients: Qumasoft QVCS Enterprise 2.1.18
Qumasoft QVCS Pro
Version: 3.10.18
Clients: Qumasoft QVCS Pro 3.10.18
Reliable Software Code Co-Op
Version: Code Co-Op 5.1a
Clients: Reliable Software Code Co-Op 5.1a
© 2010 Altova GmbH
Unterstützte Versionskontrollsysteme 301Versionskontrolle
Altova UModel 2010
Seapine Surround SCM
Version: Surround SCM Client/Server for Windows 2009.0.0
Clients: Seapine Surround SCM Client 2009.0.0
Serena Dimensions
Version: Dimensions Express/CM 10.1.3 for Win32 Server
Clients: Serena Dimensions 10.1.3 for Win32 Client
Softimage Alienbrain
Version: Alienbrain Server 8.1.0.7300
Clients: Softimage Alienbrain Essentials/Advanced Client 8.1.0.7300
SourceGear Fortress
Version: 1.1.4 Server
Clients: SourceGear Fortress 1.1.4 Client
SourceGear SourceOffsite
Version: SourceOffsite Server 4.2.0
Clients: SourceGear SourceOffsite Client 4.2.0 (Windows)
SourceGear Vault
Version: 4.1.4 Server
Clients: SourceGear Vault 4.1.4 Client
VisualSVN Server 1.6
Version: 1.6.2
Clients: Aigenta Unified SCC 1.0.6 PushOK SVN SCC 1.5.1.1 <%AC-PUSHOKSVNX64%> TamTam SVN SCC 1.2.21
302 Versionskontrolle Unterstützte Versionskontrollsysteme
© 2010 Altova GmbHAltova UModel 2010
Bitte beachten Sie:
Altova hat hat Microsoft Source Code Control Interface (MSSCCI) v1.1 – v1.3 inUModel implementiert und die Unterstützung der oben aufgelisteten Treiber undVersionskontrollsysteme getestet. Es wird erwartet, dass UModel auch etwaigezukünftige Versionen dieser Produkte unterstützen wird.
Versionskontrollsysteme, die in der obigen Tabelle nicht aufgelistet sind, die aber derMSCCI 1.1-1.3 Spezifikation entsprechen sollten ebenfalls mit UModel funktionieren.
In diesem Abschnitt wird das UModel-Projekt Bank_CSharp.ump und die dazugehörigenDateien aus dem Ordner C:\Documents and Settings\<username>\MyDocuments\Altova\UModel2010\UModelExamples\ verwendet.
Versionskontrollbefehle können auf verschiedene Arten aufgerufen werden: über den Menübefehl Projekt | Versionskontrolle
über das Kontextmenü in der Modell-Struktur durch Klicken auf die Versionskontrollschaltflächen in der Symbolleiste
"Versionskontrolle". Wählen Sie Extras | Anpassen | Symbolleisten um dieSymbolleiste zu aktivieren.
Ein Versionskontrollprojekt ist jedoch nicht dasselbe wie ein UModel-Projekt.Versionskontrollprojekte sind verzeichnisabhängig, während UModel-Projekte logischeKonstruktionen ohne Verzeichnisabhängigkeit sind.
© 2010 Altova GmbH
Installation von Versionskontrollsystemen 303Versionskontrolle
Altova UModel 2010
12.2 Installation von Versionskontrollsystemen
Dieser Abschnitt enthält nähere Informationen zum Einrichten und Installieren derverschiedenen Versionskontrollsysteme.
AccuBridge for Microsoft SCC 2008.2
http://www.accurev.com/
1. Installieren Sie die AccuRev Client Software, führen Sie den Installer aus, definieren Sieden Server, zu dem eine Verbindung hergestellt werden soll, (Hostname und Port) understellen Sie anschließend einen Arbeitsbereich.
2. Installieren Sie den AccuBridge SCC Provider. Extrahieren Sie das ZIP-Archiv in dasVerzeichnis <AccuRev installation dir>\bin.
Registrieren Sie AccuRev.dll und SccAcc.dll wie folgt:3. Öffnen Sie ein Befehlseingabefenster (wenn Sie mit Vista arbeiten, starten Sie den
Windows Explorer, gehen Sie zu C:\Windows\System32, klicken Sie auf die rechteMaustaste und führen Sie die cmd.exe “As administrator” aus).
4. Gehen Sie zum Verzeichnis <installation AccuRev dir>\bin.5. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein: Regsvr32 AccuRev.dll Regsvr32 SccAcc.dll
6. Führen Sie das Programm SwitchScc.exe aus und definieren Sie als den ProviderAccuRev.
7. Führen Sie in Windows ein Logoff und anschließend ein Login durch.
Aigenta Unified SCC 1.0.6
http://aigenta.com/products/UnifiedScc.aspx
Voraussetzungen: Source Control Client. Aigenta Unified SCC funktioniert mit:
Subversion Befehlszeilen-Client 1.5.4 unter http://subversion.tigris.org CVSNT 2.5 (Client) unter http://www.cvsnt.org Bazaar 1.9 Windows (und damit in Zusammenhang stehenden Komponenten) unter
http://bazaar-vcs.org/ (http://bazaar-vcs.org/WindowsInstall)
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Borland StarTeam Cross-Platform Client 2008 R2
http://www.borland.com/us/products/starteam
Um die Borland StarTeam Microsoft SCC Integration zu installieren, führen Sie dasSetup-Programm aus und wählen Sie bei der Installation die SCC API Integration.
Altova-Produkte können nun bei Angabe der Server-Adresse, des Endpunkts, deseinzuloggenden Benutzernamens und Passworts und Ihres Projekt- und Arbeitspfads eineVerbindung zur Speicherschnittstelle herstellen.
Codice Software Plastic SCM Professional 2.7.127.10 (SCC Plugin)
http://www.codicesoftware.com/xpproducts.aspx
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß. Es müssennur die Komponenten “client” und das “Visual Studio SCC plug-in” installiert werden.
ComponentSoftware CS-RCS (PRO) 5.1
http://www.componentsoftware.com/Products/RCS
304 Versionskontrolle Installation von Versionskontrollsystemen
© 2010 Altova GmbHAltova UModel 2010
1. Um ComponentSoftware CS-RCS (PRO) zu installieren, starten Sie dasSetup-Programm und aktivieren Sie die Option “Workstation Setup”.
2. Definieren Sie die Root für die Struktur der Speicherschnittstelle und starten Sie IhrenRechner nach Abschluss der Installation neu.
3. Über “ComponentSoftware RCS Properties” können Sie ein Projekt auswählen odererstellen und einen Arbeitsordner definieren.
Dynamsoft SourceAnywhere for VSS 5.3.2 Client
http://www.dynamsoft.com/Products/SAW_Overview.aspx
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Für die Integration mit Altova Produkten muss das Plug-in für Adobe DreamWeaver CS3 nichtinstalliert werden. Stellen Sie nach der Installation eine Server-Verbindung her und definierenSie einen Arbeitsordner.
Dynamsoft SourceAnywhere Hosted Client (22252)
http://www.dynamsoft.com/Products/SourceAnywhere-Hosting-Version-Control-Source-Control.aspx
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Für die Integration mit Altova Produkten muss das Plug-in für Adobe DreamWeaver CS3 nichtinstalliert werden.
Dynamsoft SourceAnywhere Standalone 2.2 Client
http://www.dynamsoft.com/Products/SourceAnywhere-SourceSafe-VSS.aspx
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Für die Integration mit Altova Produkten muss das Plug-in für Adobe DreamWeaver CS3 nichtinstalliert werden. Stellen Sie nach der Installation eine Server-Verbindung her und definierenSie einen Arbeitsordner.
IBM Rational ClearCase 7.0.1 (LT)
http://www-01.ibm.com/software/awdtools/clearcase/
Um IBM Rational ClearCase LT zu installieren, führen Sie das Setup-Programm aus. Sie werden aufgefordert, die Version des InstallShield Scripting-Prozessors zu
aktualisieren, wenn diese älter als Version 10.5 ist. Wählen Sie “Update it ifnecessary”.
Die Aktualisierung wird vor Beginn der Installation durchgeführt.
Wählen Sie die Standardoption “Enterprise deployment, create a network release areaand customize it using Siteprep”.
Um die Versionskontrolle mit Altova-Produkten zu integrieren, muss nur der Client installiertwerden. Aktivieren Sie nur das Kontrollkästchen "Client".
Geben Sie einen Server-Namen sowie das/die Lizenzserver Element(e) an. Gehen Sievor wie in den Beispielen, die vom Installer geliefert werden (port@server_name).
Geben Sie einen Namen für die Konfiguration an, indem Sie den Namen entsprechendbearbeiten und den Pfad zu einem Release-Bereich (Release Area) eingeben.Dieser Pfad muss einen freigegebenen Ordner definieren.
Sie können einen neuen Ordner auf Ihrem Rechner anlegen, ihn freigeben und als
© 2010 Altova GmbH
Installation von Versionskontrollsystemen 305Versionskontrolle
Altova UModel 2010
Release-Bereich (Release Area) verwenden.
In Vista müssen Sie "Network discovery" im Network and Sharing Center auf "on"setzen, um diesen Pfad zu definieren.Der Release-Bereich wird nun erstellt, einige Dateien werden hinein kopiert und einShortcut sitedefs.lnk wird erstellt.
Wenn alle Dateien kopiert wurden, fahren Sie fort, indem Sie vom Windows Exploreraus auf den Shortcut klicken.Ein neues Setup-Programm beginnt mit der Installation des Client.
Wenn das Setup-Programm beginnt, wählen Sie die Option "Install IBM RationalClearCase LT”.
Klicken Sie auf "Weiter", akzeptieren Sie das "Software License Agreement” undstarten Sie die Installation.
In Vista könnte das zweite Setup-Programm den internen Fehler: 2739 ausgeben. StartenSie in diesem Fall den Windows Explorer und gehen Sie zu C:\Windows\System32.
Klicken Sie auf die rechte Maustaste und führen Sie “cmd.exe” “As Administrator” aus.Daraufhin erscheint ein Eingabefenster.
Geben Sie “regsvr32 jscript.dll” ein. Starten Sie das Setup-Programm wieder.
Um mit in ClearCase gespeicherten Dateien zu arbeiten, sollten Sie eine Ansicht erstellen, dieauf Ihr ClearCase-Projekt verweist.
Jalindi Igloo 1.0.3
http://www.jalindi.com/igloo/
Um Jalindi Igloo mit Altova-Produkten zu verwenden, muss nur das Setup-Programmausgeführt werden, um Jalindi Igloo zu installieren.
Bitte beachten Sie: Wenn Sie Jalindi Igloo deinstallieren, werden alle anderen installierten SCC ProviderWindows Registrierschlüssel (falls vorhanden) ebenfalls gelöscht und stehen nichtmehr zur Verfügung.
Wenn Sie mit Altova-Produkten arbeiten, wird empfohlen den Modus "Auto Commit”einzustellen.
Der Modus "Auto Commit" befindet sich in den erweiterten Source Control-Optionen. Nachdem Sie einen Arbeitsbereich definiert haben, können Sie mit der Arbeit beginnen.
March-Hare CVS Suite Client 2008 (3321)
http://www.march-hare.com/cvsnt/en.asp
Eine "typical”-Installation funktioniert mit Altova-Produkten ordnungsgemäß.
Mercurialsiehe Sergey Antonovs HgScc 1.0.1
Microsoft SourceSafe 2005 with CTP
http://msdn.microsoft.com/en-us/vstudio/aa718670.aspx
Eine Standard-Installation von Microsoft Source Safe 2005 funktioniert mit Altova-Produktenordnungsgemäß.
Microsoft Team Foundation Server 2008 MSSCCI Provider
http://www.microsoft.com/downloads
306 Versionskontrolle Installation von Versionskontrollsystemen
© 2010 Altova GmbHAltova UModel 2010
Voraussetzungen: Visual Studio 2008 Team Explorer oder Visual Studio 2008 mit TeamExplorer 2008. Eine Standard-Installation funktioniert mit allen Altova-Produktenordnungsgemäß.
Perforce P4V 2008.1
http://www.perforce.com/
Beim Perforce Visual Client (P4V) haben Sie die Wahl: alle Client-Funktionen zu installieren (Standardverhalten) nur die Funktion “SCC Plug-in (P4SCC)” zu installieren.
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Wenn die Funktion “SCC Plug-in (P4SCC)” ausgewählt wird: funktionieren zwei SCC-Funktionen “Show differences” und “Source control manager”
nicht. Die Funktion “Show differences” und die Möglichkeit, den Source Control Manager zu
starten, funktionieren nicht, weil sie auf den nicht installierten Funktionen” Visual MergeTool” bzw. “Visual Client (P4V)” basieren.
Für die Vergleichsfunktion wird Drittanbietersoftware benötigt, während der SourceControl Manager nur gestartet werden kann, nachdem der “Visual Client (P4V)" explizitinstalliert wurde.
Nachdem Sie die Perforce Visual Client Installation gestartet haben, definieren Sie Ihreeigenen Client-Konfigurationseinstellungen (Server Name, Textbearbeitungsapplikation,Benutzername).
Vergessen Sie nach Abschluss der Installation nicht, einen neuen Arbeitsbereich zuerstellen oder einen vorhandenen auszuwählen.
PureCM Client 2008/3a
http://www.purecm.com/
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß. Starten Sienach der Installation den PureCM Client, um einen Server zu registrieren.
PushOK CVS SCC NT 2.1.2.5
http://www.pushok.com/soft_cvs.php
Eine Standard-Installation genügt, um PushOK CVS SCC NT zu verwenden.
Stellen Sie nach Abschluss der Installation sicher, dass Ihre Version des CVS ProxyPlug-in korrekt registriert ist.
Nach Definition eines Arbeitsbereichs können Sie anfangen, damit zu arbeiten.
<%AC-PUSHOKCVSX64%>
http://www.pushok.com/soft_cvs.php
Eine Standard-Installation genügt, um PushOK CVS SCC zu verwenden. Stellen Sie nach Abschluss der Installation sicher, dass Ihre Version des CVS Proxy
Plug-in korrekt registriert ist. Nach Definition eines Arbeitsbereichs können Sie anfangen, damit zu arbeiten.
PushOK SVN SCC 1.5.1.1
http://www.pushok.com/soft_svn.php
© 2010 Altova GmbH
Installation von Versionskontrollsystemen 307Versionskontrolle
Altova UModel 2010
Eine Standard-Installation genügt, um PushOK CVS SCC mit Altova-Produkten zu verwenden. Bei Installation unter Vista kann es vorkommen, dass die COM-Bibliothek svncom.dll nichtregistriert werden kann. Stellen Sie in diesem Fall die Installation fertig und registrieren Sie dieBibliothek folgendermaßen manuell:
1. Starten Sie ein Eingabefenster über die Option "Run as administrator".2. Geben Sie: cd “C:\Program Files\PushOK Software\SVNSCC\svn” ein3. Geben Sie den Befehl > regsvr32 svncom.dll ein.
<%AC-PUSHOKSVNX64%>
http://www.pushok.com/soft_svn.php
Eine Standard-Installation genügt, um PushOK SVN SCC mit Altova-Produkten zu verwenden.Bei Installation unter Vista kann es vorkommen, dass die COM-Bibliothek svncom.dll nichtregistriert werden kann. Stellen Sie in diesem Fall die Installation fertig und registrieren Sie dieBibliothek folgendermaßen manuell:
1. Starten Sie ein Eingabefenster über die Option "Run as administrator".2. Geben Sie: cd “C:\Program Files\PushOK Software\SVNSCC\svn” ein3. Geben Sie den Befehl > regsvr32 svncom.dll ein.
QSC Team Coherence Client 7.1.4.30
http://www.teamcoherence.com
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Wenn der Server auf dem Client-Rechner installiert ist, wird nach der Client-Installationeiner Standardverbindung erstellt.
Wenn der Server auf einem anderen Rechner installiert ist, müssen Sie im Dialogfeld"Connection Properties" des Team Coherence Client die Eigenschaft “HOSTNAME” inden Pfad zum entsprechenden Rechner ändern.
Qumasoft QVCS Enterprise 2.1.18
http://www.qumasoft.com/Voraussetzungen: J2SE 1.5 oder höher http://java.sun.com/j2se/downloads.html
Um den Qumasoft QVCS-Enterprise Client zu installieren, starten Sie den Installer. Wenn Ihr Betriebssystem Vista ist, müssen Sie das Installationsverzeichnis vom
Standardwert “C:\Program Files\QVCS-Enterprise Client” in “C:\QVCS-EnterpriseClient” ändern.
Der Grund dafür ist, dass Vista Applikationen nicht in den Bereich C:\Program Filesschreiben lässt.
1. Bearbeiten Sie die Datei “setEnv.cmd” im Installationsverzeichnis, sodass dieUmgebungsvariable JAVA_HOME auf den Ordner Ihrer JVM verweist.
Eventuell kommt es in Vista beim Speichern der Datei zu einem Problem.2. Wenn das der Fall ist, starten Sie den Windows Explorer und gehen Sie zu
C:\Windows\System32.3. Klicken Sie auf die rechte Maustaste und führen Sie “cmd.exe” “As Administrator” aus.
Daraufhin erscheint ein Eingabefenster.4. Geben Sie “cd <Installationsordner des QVCS –Enterprise Client>” ein.5. Geben Sie “Notepad setEnv.cmd” ein und bearbeiten Sie anschließend die Datei und
speichern Sie sie.
6. Führen Sie vom Installationsverzeichnis des Qumasoft QVCS-Enterprise die
308 Versionskontrolle Installation von Versionskontrollsystemen
© 2010 Altova GmbHAltova UModel 2010
Batch-Datei “gui.bat” aus.7. Fügen Sie einen Server aus dem “Server-Menü” hinzu. Geben Sie den erforderlichen
Namen, die IP-Adresse und Ports und den Log-in-Namen ein und definieren Sie einenlokalen Arbeitsbereich.
Qumasoft QVCS Pro 3.10.18
http://www.qumasoft.com/
Um Qumasoft QVCS-Pro zu installieren, führen Sie den Installer aus. Wenn Ihr Betriebssystem Vista ist, müssen Sie das Installationsverzeichnis vom
Standardwert “C:\Program Files\QVCSBin” in “C:\QVCSBin” ändern.
Der Grund dafür ist, dass Vista Applikationen nicht in den Bereich C:\Program Filesschreiben lässt.
Starten Sie nach Fertigstellung der Installation den QVCS 3.10 Client, erstellen Sieeinen neuen Benutzer und aktivieren Sie die Ide Integration durch Auswahl desUntermenüs “Ide Integration” im Menü "Admin" und Hinzufügen von QVCS alsVersionskontroll-Tool.
Erstellen Sie ein Projekt und definieren Sie einen Arbeitsbereich.
Reliable Software Code Co-Op 5.1a
http://www.relisoft.com/co_op/index.htm
Seapine Surround SCM Client 2009.0.0
http://www.seapine.com/surroundscm.html
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß. Nach der Installation muss eine Verbindung zu einem Server hergestellt werden.
Serena Dimensions 10.1.3 for Win32 Client
http://www.serena.com/Products/dimensions/
Führen Sie eine “Typical” Installation des Serena Dimension Client durch. Definieren Sie den WEB Client Hostnamen und die Port-Nummer, wenn Sie dazu
aufgefordert werden.
Sergey Antonovs HgSCC 1.0.1 for Mercurial SCS
http://www.newsupaplex.pp.ru/hgscc_news_eng.htmlEine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß
Softimage Alienbrain Essentials/Advanced Client 8.1.0.7300
http://www.alienbrain.com/
Führen Sie eine “Typical” Installation der Alienbrain Client Software aus und installierenSie anschließend die Alienbrain Microsoft Visual Studio Integration.
Um mit Altova-Produkten zu arbeiten, müssen Sie Microsoft Visual Studio nichtinstallieren.
Beim ersten Öffnen eines Projekts von der Versionskontrolle aus oder beim Hinzufügeneines Projekts zur Versionskontrolle, werden Sie aufgefordert einigeBenutzereinstellungen zu definieren, z.B. Ihen Server und die Projektdatenbank, zu dereine Verbindung hergestellt werden soll.
SourceGear Fortress 1.1.4 Client
© 2010 Altova GmbH
Installation von Versionskontrollsystemen 309Versionskontrolle
Altova UModel 2010
http://www.sourcegear.com/fortress
Eine Standard-Installation von SourceGear Fortress Client funktioniert mit Altova-Produkten.
SourceGear SourceOffsite Client 4.2.0 (Windows)
http://www.sourcegear.com/sos/Eine Standard-Installation von SourceOffsite Client funktioniert mit Altova-Produkten.
SourceGear Vault 4.1.4 Client
http://www.sourcegear.com/vault
Eine Standard-Installation von SourceGear Vault Client funktioniert mit Altova-Produkten.
TamTam CVS SCC 1.2.36
http://www.daveswebsite.com/software/tamtam
Voraussetzungen: CVSNT 2.5 (client) unter http://www.cvsnt.org
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Um eine Verbindung zur CVS-Speicherschnittstelle herzustellen, müssen Sie CVSNTinstallieren.
Öffnen Sie im Altova-Produkt die erweiterten Optionen der “Versionskontrolle” undgeben Sie den Pfad zur Datei cvs.exe ein.
TamTam SVN SCC 1.2.21
http://www.daveswebsite.com/software/tamtamsvn
Voraussetzungen: Subversion Command Line Client 1.5.4 unter http://subversion.tigris.org
Eine Standard-Installation funktioniert mit allen Altova-Produkten ordnungsgemäß.
Um eine Verbindung zur SVN-Speicherschnittstelle herzustellen, müssen Sie denSubversion Command Line Client installieren und in denAltova-Versionskontrolloptionen den Pfad zur ausführbaren Datei svn.exe definieren.
Nach Start von UModel müssen Sie den SCC Provider registrieren.
Auf einem Vista Rechner kann die CSS-Registrierung fehlschlagen. Falls dies der Fall ist, suchen Sie im Windows Explorer das Verzeichnis, das die
ausführbare Altova-Applikationsdatei enthält. Klicken Sie auf die rechte Maustaste und führen Sie die Datei “As Administrator” aus.
Die SCC-Registrierung sollte jetzt klappen.
310 Versionskontrolle Versionskontrolle und Vergleich mit Altova DiffDog
© 2010 Altova GmbHAltova UModel 2010
12.3 Versionskontrolle und Vergleich mit Altova DiffDog
Sie können bestimmte Versionskontrollsysteme für die Verwendung von Altova DiffDog alsVersionskontroll-Vergleichstool konfigurieren. Eine Liste davon sowie eine Anleitung zumKonfigurieren der einzelnen Systeme finden Sie weiter unten. In UModel können Sie dies überdas Dialogfeld "Optionen" (Extras | Optionen, Abbildungt unten) auf dem Register"Versionskontrolle" tun.
Bei Verwendung einer 64-Bit-Version von UModel mit einem 32-Bit-Versionskontrollprogrammist die Option "Statusaktualisierungen alle ...ms durchführen" (Extras | Optionen) automatischausgegraut und kann nicht ausgewählt werden.
Das Kontrollkästchen "Statusaktualisierung im Hintergrund alle xxx ms" ist standardmäßigdeaktiviert, d.h. es werden keine Statusaktualisierungen durchgeführt. Aktivieren Sie dasKontrollkästchen und geben Sie in das Feld einen Wert ein, wenn alle xx ms eineStatusaktualisierung durchgeführt werden soll. Bei 64-Bit-Versionen, die mit32-Bit-Versionskontroll-Plugins arbeiten, hat diese Option keine Auswirkung.
Wählen Sie das gewünschte Versionskontrollsystem auf dem Register "Versionskontrolle" ausund klicken Sie auf die Schaltfläche "Erweitert". Das Dialogfeld, das sich daraufhin öffnet, ist jenach Versionskontrollsystem unterschiedlich. Beachten Sie bei der Konfiguration folgendePunkte:
Wenn Sie eine Standardinstallation von Altova DiffDog durchgeführt haben, so lautetder Dateipfad zur ausführbaren Altova DiffDog Datei:c:\program files\altova\diffdog2010\DiffDog.exe
Wenn Altova DiffDog in einem anderen Ordner auf Ihrem System installiert ist, fügenSie den entsprechenden Wert ein, wo dies erforderlich ist.
Verwenden Sie DiffDog nicht zum Zusammenführen von UModel-Projektdateien (*.ump).
Aigenta Unified SCC 1.0.6
© 2010 Altova GmbH
Versionskontrolle und Vergleich mit Altova DiffDog 311Versionskontrolle
Altova UModel 2010
http://aigenta.com/products/UnifiedScc.aspx
Mit den folgenden Schritten wird Altova DiffDog in Aigenta Unified SCC integriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 2. Wählen Sie das Register “Comparison and merging” und definieren Sie den
vollständigen DiffDog-Dateipfad als Vergleichstool.
Borland StarTeam Cross-Platform Client 2008 R2
http://www.borland.com/us/products/starteam
Mit den folgenden Schritten wird Altova DiffDog in Borland Start Team integriert:1. Verwenden Sie die "Personal Options" des StarTeam Client (Tools - Personal options –
File - Alternate applications)2. Compare utility: Geben Sie den vollständigen Pfad zu DiffDog ein3. Compare utility options: $file1 $file2
ComponentSoftware CS-RCS (PRO) 5.1
http://www.componentsoftware.com/Products/RCS
Mit den folgenden Schritten wird Altova DiffDog in ComponentSoftware CS-RCS (Pro) integriert:1. Gehen Sie zu den ComponentSoftware CS-RCS Properties.2. Wählen Sie auf dem Register “File Types” eine Dateierweiterung aus und bearbeiten
Sie sie.3. Geben Sie den Wert “Custom Tool” für das “Difference Analysis Tool“ ein bzw. wählen
Sie ihn aus und durchsuchen Sie die Struktur, um den vollständigen Pfad zu DiffDogeinzufügen.
Dynamsoft SourceAnywhere for VSS 5.3.2 Client
http://www.dynamsoft.com/Products/SAW_Overview.aspx
Mit den folgenden Schritten wird Altova DiffDog in Dynamsoft SourceAnywhere for VSSintegriert:1. Gehen Sie zu den Dynamic SourceAnywhere For VSS Client-Optionen.2. Definieren Sie mit den Argumenten “%FIRST_FILE%” “%SECOND_FILE%” den
vollständigen DiffDog Pfad als externe Applikation für diff/merge.
Warnung: Führen Sie diese Einstellungen nicht über die Altova-Produktoptionen durch, da Sie hierkeine externen Applikationsparameter einsetzen können.
Dynamsoft SourceAnywhere Hosted Client (22252)
http://www.dynamsoft.com/Products/SourceAnywhere-Hosting-Version-Control-Source-Control.aspx
Dynamsoft SourceAnywhere Standalone 2.2 Client
http://www.dynamsoft.com/Products/SourceAnywhere-SourceSafe-VSS.aspx
Mit den folgenden Schritten wird Altova DiffDog in Dynamsoft SourceAnywhere Hosted undDynamsoft SourceAnywhere Standalone integriert:
1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert...".2. Definieren Sie mit den Argumenten “%FIRST_FILE%” “%SECOND_FILE%” den
vollständigen DiffDog-Pfad als externe Programmapplikation für diff/merge.3.
Warnung: DiffDog funktioniert nur dann mit ump-Dateien, wenn der “Typ” in den Eigenschaftenauf “Mergeable" gesetzt ist. Sie können diese Eigenschaft in UModel durch Ausführen des
312 Versionskontrolle Versionskontrolle und Vergleich mit Altova DiffDog
© 2010 Altova GmbHAltova UModel 2010
Befehls “Eigenschaften anzeigen” und definieren der Eigenschaft im Abschnitt "allgemein"festlegen. Dies muss allerdings für jede ump-Datei erneut definiert werden. Besser ist es, diesim Dynamsoft SourceAnywhere Standalone Server Manager zu definieren.Wählen Sie IhreSpeicherschnittstelle aus, anschließend "Mergeable File Types" und fügen Sie die Erweiterung"ump" hinzu. Die neue Einstellung wird nun auf alle ump-Dateien angewendet.
Jalindi Igloo 1.0.3
http://www.jalindi.com/igloo/
Mit den folgenden Schritten wird Altova DiffDog in Jalindi Igloo integriert:1. Wählen Sie in UModel den Befehl "Unterschiede anzeigen". 2. Öffnen Sie den Bereich “Show differences or Merge Files” 3. Definieren Sie den “External Diff Command” durch Eingabe des vollständigen
DiffDog-Pfads als externe Diff EXE.
Warnung: Bei Verwendung des Standard-Diff-Editors CvsConflictEditor kann es zu Problemenbeim Vergleichen von Dateien mit besonders langen Zeilen kommen. Wir empfehlen Ihnen, anallen Dateien (v.a. ump-Dateien) ein "pretty print" durchzuführen, bevor Sie diese in derSpeicherschnittstelle speichern. Dadurch wird die Zeilenlänge limitiert, sodass es zu keinenProblemen mit dem CVSConflictEditor kommt.
March-Hare CVS Suite Client 2008 (3321)
http://www.march-hare.com/cvsnt/en.asp
Mit den folgenden Schritten wird Altova DiffDog in Marc-Hare CVS Suite 2008 integriert:1. Gehen Sie zu den TortoiseCVS Preferences und wählen Sie das Register "Tools".2. Definieren Sie den vollständigen DiffDog-Pfad als Diff-Applikation und die Parameter
“%1” “%2” als Parameter für den Vergleich in beide Richtungen.
Mercurialsiehe Sergey Antonovs HgScc 1.0.1
Microsoft SourceSafe 2005 with CTP
http://msdn.microsoft.com/en-us/vstudio/aa718670.aspx
Mit den folgenden Schritten wird Altova DiffDog in Microsoft SourceSafe 2005 integriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 2. Klicken Sie auf das Register "Custom Editors" und geben Sie die folgende Befehlszeile
in das Befehlszeilenfeld ein: "C:\Program Files\Altova\DiffDog2010\DiffDogexe %1 %23. Wählen Sie über die Auswahlliste "Operation" den Befehl "File Difference".
Microsoft Team Foundation Server 2008 MSSCCI Provider
http://www.microsoft.com/downloadsVoraussetzungen: Visual Studio 2008 Team Explorer oder Visual Studio 2008 mit Team
Explorer 2008. Mit den folgenden Schritten wird Altova DiffDog in Microsoft Visual StudioTeam System 2008 Team Foundation Server MSSCC1 Provider integriert:
1. Konfigurieren Sie in den Manager-Optionen (Visual Studio 2008Team Explorer oderVisual Studio 2008) Altova DiffDog als neues Benutzertool
2. Wählen Sie als Plug-in Visual Studio Team Foundation Server Source.3. Konfigurieren Sie durch Angabe der Erweiterungen die Dateien, die Sie mit DiffDog
vergleichen möchten, sowie den vollständigen Dateipfad zu DiffDog.
Perforce P4V 2008.1
http://www.perforce.com/
© 2010 Altova GmbH
Versionskontrolle und Vergleich mit Altova DiffDog 313Versionskontrolle
Altova UModel 2010
Mit den folgenden Schritten wird Altova DiffDog in Perforce 2008 integriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 2. Wählen Sie im Bereich "Preferences” das Register "Diff". 3. Aktivieren Sie als Standardvergleichstool das Feld “Other application” und geben Sie
den vollständige Pfad zu DiffDog ein.
PushOK CVS SCC NT 2.1.2.5,PushOK SVN SCC 1.5.1.1<%AC-PUSHOKCVSX64%><%AC-PUSHOKSVNX64%>
http://www.pushok.com/soft_cvs.php
Mit den folgenden Schritten wird Altova DiffDog in PushOK CVS NT und PushOK SVN SCCintegriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert..."2. Wählen Sie das Register "CVS Executables".3. Wählen Sie im Feld "Diff/merge" den Wert "External merge/compare tool".4. Fügen Sie den vollständigen DiffDog-Dateipfad ein.5. Bearbeiten Sie im Feld "2 way diff cmd” den Wert “%first %second”.
Warnung: Bei Verwendung des Standard-Vergleichseditors CvsConflictEditor kann es zuProblemen beim Vergleich von Dateien mit sehr langen Zeilen kommen. Wir empfehlen Ihnen,an allen Dateien (v.a. ump-Dateien) ein "pretty print" durchzuführen, bevor Sie diese in derSpeicherschnittstelle speichern. Dadurch wird die Zeilenlänge limitiert, sodass es zu keinenProblemen mit dem CVSConflictEditor kommt.
QSC Team Coherence Client 7.1.4.30
http://www.teamcoherence.com
Mit den folgenden Schritten wird Altova DiffDog in Team Coherence Version Manager integriert:1. Gehen Sie zu den Team Coherence Client-Optionen “Difference Viewer”2. Geben Sie den vollständigen DiffDog-Dateipfad als Default Difference
Viewer-Applikation an.3. Definieren Sie als Parameter: “$LF” “$RF”.
Warnung: Unter Umständen werden die neuen Einstellungen erst nach einem Windows Logoffangewendet.
Qumasoft QVCS Enterprise 2.1.18
http://www.qumasoft.com/
Mit den folgenden Schritten wird Altova DiffDog in Qumasoft QVCS-Enterprise integriert:1. Fügen Sie das Qumasoft QVCS-Enterprise Installationsverzeichnis zur
Umgebungsvariablen "Path" hinzu.2. Gehen Sie zu den QVCS Enterprise User Preferences.3. Aktivieren Sie unter "Utilities" das Kontrollkästchen “Use External Visual Compare Tool”4. Definieren Sie als "Visual Compare Command Line":
<vollständiger DiffDog-Pfad> “file1Name file2Name”
Qumasoft QVCS Pro 3.10.18
http://www.qumasoft.com/
Mit den folgenden Schritten wird Altova DiffDog in Qumasoft QVCS-Pro integriert:
314 Versionskontrolle Versionskontrolle und Vergleich mit Altova DiffDog
© 2010 Altova GmbHAltova UModel 2010
1. Gehen Sie zu den QVCS 3.10 Client Preferences.2. Definieren Sie unter "Utilities" den vollständigen Pfad zu DiffDog als visuelles
Vergleichstool mit den Parametern “%s %s “
Seapine Surround SCM Client 2009.0.0
http://www.seapine.com/surroundscm.html
Mit den folgenden Schritten wird Altova DiffDog in Seapine Surround SCM integriert:1. Gehen Sie zu den Benutzeroptionen des Surround SCM Client und dem Abschnitt
(Diff/Merge).2. Bearbeiten Sie die Diff/Merge-Einstellungen, damit der Vergleich mit der ausgewählten
Applikation durchgeführt wird.3. Geben Sie mit den Parametern “%1” “%2” den vollständigen DiffDog-Pfad ein. 4. Starten Sie den Surround SCM Client und die Altova-Produkte erneut.
Sergey Antonovs HgSCC 1.0.1
http://www.newsupaplex.pp.ru/hgscc_news_eng.html
Mit den folgenden Schritten wird Altova DiffDog in Mercurial integriert:1. Klicken Sie auf dem Register "Versionskontroll" auf das Register Erweitert.2. Wählen Sie das Vergleichstool “custom” und definieren Sie den vollständigen Pfad zu
DiffDog.
SourceGear Fortress 1.1.4 Client
http://www.sourcegear.com/fortress
SourceGear Vault 4.1.4 Client
http://www.sourcegear.com/vault
Mit den folgenden Schritten wird Altova DiffDog in SourceGear Fortress and SourceGear Vaultintegriert:
1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 2. Definieren Sie die Diff/Merge Vault-Optionen durch Angabe des vollständigen
DiffDog-Pfads und Verwendung der Argumente:/ro1 /ro2 /title1:"%LEFT_LABEL%" /title2:"%RIGHT_LABEL%" "%LEFT_PATH%""%RIGHT_PATH%"
SourceGear SourceOffsite Client 4.2.0 (Windows)
http://www.sourcegear.com/sos/
Mit den folgenden Schritten wird Altova DiffDog in SourceGear SourceOffsite integriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 1. Definieren Sie als “External Programs”, “Application for comparing files” den
vollständigen DiffDog-Pfad.
TamTam CVS SCC 1.2.36,TamTam SVN SCC 1.2.21
http://www.daveswebsite.com/software/tamtamGo
Mit den folgenden Schritten wird Altova DiffDog in TamTam CVS SCC und TamTam SVN SCCintegriert:1. Klicken Sie auf dem Register "Versionskontrolle" auf die Schaltfläche "Erweitert". 2. Definieren Sie den vollständigen DiffDog-Pfad als externes Tool für Diff/Merge und
Conflict.
Warnung: Bei Verwendung des Standard-Vergleichseditors CvsConflictEditor kann es zuProblemen beim Vergleich von Dateien mit sehr langen Zeilen kommen. Wir empfehlen Ihnen,
© 2010 Altova GmbH
Versionskontrolle und Vergleich mit Altova DiffDog 315Versionskontrolle
Altova UModel 2010
an allen Dateien (v.a. ump-Dateien) ein "pretty print" durchzuführen, bevor Sie diese in derSpeicherschnittstelle speichern. Dadurch wird die Zeilenlänge limitiert, sodass es zu keinenProblemen mit dem CVSConflictEditor kommt.
316 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4 Versionskontrollbefehle
Die Versionskontrollbefehle von UModel werden in den folgenden Abschnitten anhand vonVisual SourceSafe angezeigt.
Die Beschreibung der im Folgenden beschriebenen Versionskontrollbefehle gelten nur 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 zurVerfügung stehen.
Aus Versionskontrolle öffnenVersionskontrolle aktivierenAktuellste Version holenAbrufenOrdner abrufenAuscheckenEincheckenAuschecken rückgängig...Zu Versionskontrolle hinzufügenVon Versionskontrolle ausgliedernAus Versionskontrolle freigebenVerlauf anzeigenUnterschiede anzeigenEigenschaften anzeigenStatus aktualisierenVersionskontrollmanagerVersionskontrolle wechseln
© 2010 Altova GmbH
Versionskontrollbefehle 317Versionskontrolle
Altova UModel 2010
12.4.1 Aus Versiopskontrolle öffnen
Mit dem Befehl "Aus Versionskontrolle öffnen" wird ein lokales Projekt anhand einerbestehenden Versionskontrolldatenbank erstellt und unter Versionskontrolle - in diesem FallSourceSafe - gestellt.
1. Wählen Sie Projekt | Versionskontrolle | Aus Versionskontrolle öffnen. Daraufhinwird das Anmeldedialogfeld geöffnet, in dem Sie Ihre Anmeldedaten eingeben, bevorSie fortfahren können. Daraufhin wird das Dialogfeld "Create local project fromSourceSafe" angezeigt.
2. Definieren Sie das Verzeichnis, das das neue lokale Projekt enthalten soll, z.B.c:\temp\ssc. Dies wird zum neuen Arbeitsverzeichnis oder dem Auscheck-Ordner.
3. Wählen Sie das gewünschte SourceSafe-Projekt aus, z.B. Bank_CSharp. Wenn derhier von Ihnen definierte Ordner noch nicht existiert, erscheint ein Dialogfeld, in demSie aufgefordert werden, ihn zu erstellen.
4. Klicken Sie auf Ja, um das neue Verzeichnis zu erstellen. Das Dialogfeld "Öffnen" wirdangezeigt.
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.
318 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
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 Versionskontrollel
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 dieUModel-Projektdatei (oder Codedatei) zur Bearbeitung ausgecheckt wurde.Das Sternchen in der Titelleiste der Applikation bedeutet, dass diese Datei verändert wurde.Beim Schließen werden Sie aufgefordert, die Datei zu speichern.
oder Das Personensymbol zeigt an, dass die Datei(en) von jemand anderem im Netzwerk oder vonIhnen in ein anderes Arbeitsverzeichnis ausgecheckt wurde(n).
© 2010 Altova GmbH
Versionskontrollbefehle 319Versionskontrolle
Altova UModel 2010
12.4.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 |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 der verschiedenen Dateien wird abgerufen und imFenster "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.
320 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.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 erweitertenAbrufoptionen definieren.
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
holen möchten.2. Wählen Sie Projekt | Versionskontrolle | Aktuellste Version holen.
© 2010 Altova GmbH
Versionskontrollbefehle 321Versionskontrolle
Altova UModel 2010
12.4.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 "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 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.
322 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.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.
© 2010 Altova GmbH
Versionskontrollbefehle 323Versionskontrolle
Altova UModel 2010
12.4.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ürandere Benutzer 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
Dateien mittels Strg + Klick) Projektordner - klicken Sie in der Modellstruktur auf den Ordner (oder mehrere Ordner
mittels 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.
324 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
© 2010 Altova GmbH
Versionskontrollbefehle 325Versionskontrolle
Altova UModel 2010
12.4.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 Dateienin 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
Dateien mittels Strg + Klick) Ordner - klicken Sie in der Modellstruktur auf die Ordner (mittels Strg + Klick)
oder
Das Vorhängeschloss-Symbol zeigt an, dass sich die Datei/der Ordner unterVersionskontrolle befindet, aber derzeit nicht ausgecheckt ist.
326 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.8 Auschecken rückgängig...
Mit diesem Befehl werden Änderungen in zuvor ausgecheckten Dateien, also lokalaktualisierten Dateien verworfen. Es werden die alten Dateien aus derVersionskontrolldatenbank beibehalten.
So machen Sie das Auschecken rückgängig..
Wählen Sie die Dateien in der Modellstruktur aus Wählen Sie Projekt | Versionskontrolle | Auschecken rückgängig.
Anmerkung:Sie können die Anzahl der Dateien ändern, indem Sie die einzelnen Kontrollkästchen inder Liste der Dateien aktivieren.
Die Option "Auschecken rückängig" kann auf die folgenden Dateien angewendet werden: Einzelne Dateien - klicken Sie in der Modell-Struktur auf die Datei (oder mehrere
Dateien mittels 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.
Mit dem Kontrollkästchen "Make writable" wird das "read-only" Attribut der abgerufenen Dateienentfernt.
© 2010 Altova GmbH
Versionskontrollbefehle 327Versionskontrolle
Altova UModel 2010
12.4.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 Sieaufgefordert den Arbeitsbereichsordner und den Pfad anzugeben, unter dem das Projektgespeichert werden soll.
Nachdem Sie die UModel-Projektdatei (*.ump) unter Versionskontrolle gestellt haben, könnenSie anschließend die beim Code Engineering erzeugten Codedateien ebenfalls zurVersionskontrolle hinzufügen. Das in diesem Abschnitt verwendete Arbeitsverzeichnis ist c:\temp\ssc\Bank_CSharp.
Bitte beachten Sie, dass die generierten Codedateien und das UModel-Projekt in das oderunterhalb desselben SourceSafe-Arbeitsverzeichnisses gelegt werden müssen.
z.B ...\Bank_CSharp1. Erweitern Sie in der Modell-Struktur den Ordner "Component View" und navigieren Sie
zur Komponente "BankView".
2. Klicken Sie auf die BankView-Komponente und klicken Sie im Fenster "Eigenschaften"auf das Durchsuchen-Symbol neben dem Feld "Verzeichnis".
3. Ändern Sie das Code Engineering-Verzeichnis z.B. in c:\TEMP\ssc\Bank_CSharp\codegenWenn vorher ein anderer Ordner verwendet wurde, erscheint ein Meldungsfeld.
4. Klicken Sie nach Ändern des Verzeichnisses auf OK.5. Wählen Sie den Menübefehl Projekt | Merge Programmcode aus UModel-Projekt.6. Ä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 erstellten
328 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
Dateien unter Versionskontrolle stellen möchten.
7. Klicken Sie auf Ja.8. Daraufhin wird das Dialogfeld "Zu Versionskontrolle hinzufügen" geöffnet, in dem Sie
die Dateien auswählen können, die unter Versionskontrolle gestellt werden sollen.
9. 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.
© 2010 Altova GmbH
Versionskontrollbefehle 329Versionskontrolle
Altova UModel 2010
12.4.10Von Verionskontrolle 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 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
330 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.11Aus Versionskontrolle freigeben
Mit diesem Befehl werden Dateien aus anderen Projekten/Ordnern im ausgewählten Ordner indie Versionskontrollspeicherschnittstelle in Form von freigegebenen Dateien einem Brancheingefügt.Um dem Freigeben-Befehl verwenden zu können, müssen Sie für das Projekt, das Siefreigeben möchten, Ein- und Auscheck-Rechte besitzen.
So geben Sie eine Datei aus der Versionskontrolle frei:1. Wählen Sie den gewünschten Ordner in der Modellstruktur aus und wählen Sie den
Befehl Projekt | Versionskontrolle | Aus Versionskontrolle freigeben, z.B. dieKomponente BankView im Ordner Component View.
2. Wählen Sie im Listenfeld "Projekte" den Projektordner aus, der die Datei enthält.
3. Wählen Sie im Listenfeld "Files to share" die gewünschte Datei aus und klicken Sie 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.
© 2010 Altova GmbH
Versionskontrollbefehle 331Versionskontrolle
Altova UModel 2010
12.4.12Verlauf 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.
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ßen
332 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
Schließ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.
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 zurAnzeige der Unterschiede zwischen den beiden Dateiversionen definieren können.
Mit Hilfe von Strg + Klick können Sie zwei Dateiversionen in diesem Fenster markieren.Klicken Sie anschließend auf Diff, um die Unterschiede zwischen den beiden 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.
© 2010 Altova GmbH
Versionskontrollbefehle 333Versionskontrolle
Altova UModel 2010
12.4.13Unterschiede anzeigen
Dieser Befehl ermöglicht die Anzeige von Unterschieden zwischen der in derVersionskontroll-Ablage befindlichen und der gleichnamigen Datei, die Sie ein-/ausgecheckthaben.
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äche2 beliebige Dateien auswählen.
So zeigen Sie die Unterschiede zwischen zwei Dateien an:
1. Klicken Sie in der Modell-Struktur auf eine Datei.2. Wählen Sie die Menüoption Projekt | Versionskontrolle | Unterschiede anzeigen.
Es erscheint ein Dialogfeld, in dem Sie weitere Informationen eingeben können.
3. Wählen Sie die gewünschten Einträge und bestätigen Sie mit OK.
334 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
Die Unterschiede zwischen beiden Dateien werden in beiden Fenstern farblich markiert(in diesem Beispiel wird MS Source-Safe verwendet).
© 2010 Altova GmbH
Versionskontrollbefehle 335Versionskontrolle
Altova UModel 2010
12.4.14Eigenschaften 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.
Dieser Befehl kann jeweils nur an einer einzelnen Datei ausgeführt werden.
336 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.15Status aktualisieren
Mit diesem Befehl aktualisieren Sie den Status aller Projektdateien unabhängig von ihremderzeitigen Status.
© 2010 Altova GmbH
Versionskontrollbefehle 337Versionskontrolle
Altova UModel 2010
12.4.16Versionskontrollmanager
Mit diesem Befehl starten Sie die ursprüngliche Oberfläche Ihrer Versionskontroll-Software.
338 Versionskontrolle Versionskontrollbefehle
© 2010 Altova GmbHAltova UModel 2010
12.4.17Versionskontrolle 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.
340 UModel Diagrammsymbole
© 2010 Altova GmbHAltova UModel 2010
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
werden können.
Beziehung - Zeigt eine Liste von Beziehungsarten an, die zwischen Elementen imDiagramm erstellt werden können.
© 2010 Altova GmbH
Aktivitätsdiagramm 341UModel Diagrammsymbole
Altova UModel 2010
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
342 UModel Diagrammsymbole Klassendiagramm
© 2010 Altova GmbHAltova UModel 2010
13.2 Klassendiagramm
Beziehung:AssoziationAggregationKompositionAssoziationsklasseAbhängigkeitVerwendungSchnittstellenrealisierungGeneralisierung
Hinzufügen:PaketKlasseSchnittstelleEnumerationDatentypPrimitivtypProfil StereotypProfilzuweisungInstanzspezifikation
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Kommunikationsdiagramm 343UModel Diagrammsymbole
Altova UModel 2010
13.3 Kommunikationsdiagramm
HinzufügenLebenslinieNachricht (Aufruf)Nachricht (Antwort)Nachricht (Erstellung)Nachricht (Löschung)
AnmerkungAnmerkung verknüpfen
344 UModel Diagrammsymbole Kompositionsstrukturdiagramm
© 2010 Altova GmbHAltova UModel 2010
13.4 Kompositionsstrukturdiagramm
HinzufügenKollaborationKollaborationsanwendungPart (Eigenschaft)KlasseSchnittstellePort
BeziehungKonnektorAbhängigkeit (Rollenbindung)SchnittstellenrealisierungVerwendung
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Komponentendiagramm 345UModel Diagrammsymbole
Altova UModel 2010
13.5 Komponentendiagramm
Hinzufügen:PaketSchnittstelleKlasseKomponenteArtefakt
Beziehung:RealisierungSchnittstellenrealisierungVerwendungAbhängigkeit
AnmerkungAnmerkung verknüpfen
346 UModel Diagrammsymbole Deployment-Diagramm
© 2010 Altova GmbHAltova UModel 2010
13.6 Deployment-Diagramm
Hinzufügen:PaketKomponenteArtefaktKnotenGerätAusführungsumgebung
Beziehung:ManifestationDeploymentAssoziationGeneralisierungAbhängigkeit
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Interaktionsübersichtsdiagramm 347UModel Diagrammsymbole
Altova UModel 2010
13.7 Interaktionsübersichtsdiagramm
HinzufügenAufrufverhalten - Aktion (Interaktion)Aufrufverhalten - Aktion (Interaktionsverwendung)VerzweigungsknotenVerbindungsknotenStartknotenAktivitätsendknotenParallelisierungsknotenParallelisierungsknoten (Horizontal)SynchronisationsknotenSynchronisationsknoten (Horizontal)Zeitdauerbedingung
BeziehungKontrollfluss
AnmerkungAnmerkung verknüpfen
348 UModel Diagrammsymbole Objektdiagramm
© 2010 Altova GmbHAltova UModel 2010
13.8 Objektdiagramm
Beziehung:AssoziationAssoziationsklasseAbhängigkeitVerwendungSchnittstellenrealisierungGeneralisierung
Hinzufügen:PaketKlasseSchnittstelleEnumerationDatentypPrimitivtypInstanzspezifikation
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Paketdiagramm 349UModel Diagrammsymbole
Altova UModel 2010
13.9 Paketdiagramm
HinzufügenPaketProfil
BeziehungAbhängigkeitPaketimportPaketmergeProfilzuweisung
AnmerkungAnmerkung verknüpfen
350 UModel Diagrammsymbole Profildiagramm
© 2010 Altova GmbHAltova UModel 2010
13.10 Profildiagramm
HinzufügenProfilStereotyp
BeziehungGeneralisierungProfilzuweisungPaketimportElementimport
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Sequenzdiagramm 351UModel Diagrammsymbole
Altova UModel 2010
13.11 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 Anworten auf Nachrichten (Call) ein/aus
352 UModel Diagrammsymbole Zustandsdiagramm
© 2010 Altova GmbHAltova UModel 2010
13.12 Zustandsdiagramm
HinzufügenEinfacher ZustandZusammengesetzter ZustandOrthogonaler ZustandUnterautomatenzustand
AnfangszustandEndzustandEintrittspunktAustrittspunktEntscheidungKreuzungBeendungGabelungGabelung (horizontal)VereinigungVereinigung (horizontal)Deep historyShallow historyVerbindungspunktreferenz
BeziehungTransition
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
Zeitverlaufsdiagramm 353UModel Diagrammsymbole
Altova UModel 2010
13.13 Zeitverlaufsdiagramm
HinzufügenLebenslinie (Zustand/Bedingung)Lebenslinie (Allgemeiner Wert)Tick-SymbolAuslösendes EreignisZeitdauerbedingungZeitbedingung
Nachricht (Aufruf)Nachricht (Antwort)Asynchrone Nachricht (Aufruf)
AnmerkungAnmerkung verknüpfen
354 UModel Diagrammsymbole Use Case-Diagramm
© 2010 Altova GmbHAltova UModel 2010
13.14 Use Case-Diagramm
Hinzufügen:PaketAkteurUse Case
Beziehung:AssoziationGeneralisierungInclude Extend
AnmerkungAnmerkung verknüpfen
© 2010 Altova GmbH
XML-Schema-Diagramm 355UModel Diagrammsymbole
Altova UModel 2010
13.15 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
358 UModel Referenz
© 2010 Altova GmbHAltova UModel 2010
14 UModel Referenz
Im folgenden Abschnitt sind alle Menüs und Menüoptionen in UModel mit einer kurzenBeschreibung dazu aufgelistet.
© 2010 Altova GmbH
Datei 359UModel Referenz
Altova UModel 2010
14.1 Datei
NeuLöscht das Diagrammregister, falls ein früheres Projekt vorhanden ist, und erstellt ein neues UModel-Projekt.
ÖffnenÖffnet ein zuvor definiertes Modellierungsprojekt. Wählen Sie im Dialogfeld "Öffnen" eine 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 dasKontrollkästchen Microsoft® SharePoint® Server. Nähere Informationen zum Arbeitenmit Dateien dieses Servertyps finden Sie unter den Anmerkungen weiter unten zuMicrosoft® SharePoint® Server.
360 UModel Referenz Datei
© 2010 Altova GmbHAltova UModel 2010
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,die WebDAV und Microsoft SharePoint Server unterstützen. Die unterstütztenProtokolle sind 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, wennSie z.B. mit einem EPS oder einem Datenbanksystem arbeiten; wählen Sie in diesemFall die 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 Stauts derDatei (Eingecheckt/Ausgecheckt) kennzeichnen.
© 2010 Altova GmbH
Datei 361UModel Referenz
Altova UModel 2010
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" (siehe Abbildung 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.
Neu laden
362 UModel Referenz Datei
© 2010 Altova GmbHAltova UModel 2010
Dient 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 nachWahl als PNG-Datei oder EMF- (Enhanced Metafile) Datei. Es können nun auch sehr großePNG-Dateien im Gigabyte-Bereich gespeichert werden.
Alle Diagramme als Bilder speichernSpeichert alle Diagramme des derzeit aktiven Projekts als .PNG- oder .EMF (enhancedmetafile)-Datei.
Aus XMI-Datei importierenImportiert eine zuvor exportierte XMI-Datei. Wenn die Datei mit UModel erzeugt wurde, werdenalle Erweiterungen usw. beibehalten.
In XMI-Datei exportierenExportiert das Modell als XMI-Datei. Sie können die UML-Version sowie die zu exportierendenIDs auswählen. Nähere Informationen siehe XMI - XML Metadata Interchange.
Als Mail sendenÖffnet Ihre Standard-Mailapplikation und fügt das aktuelle UModel Projekt als Anhang ein.
DruckenÖffnet das Dialogfeld "Drucken", über das Sie Ihr Modellierungsprojekt ausdrucken können.
© 2010 Altova GmbH
Datei 363UModel Referenz
Altova UModel 2010
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 enthaltenenUML-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.
364 UModel Referenz Bearbeiten
© 2010 Altova GmbHAltova UModel 2010
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 Schrittevorwärts und rückwärts bewegen.
Ausschneiden/Kopieren/LöschenDie Windows-Standardbearbeitungsbefehle gestatten Ihnen, Modellelemente auszuschneiden,zu kopieren, usw. Nähere Informationen dazu finden Sie unter Ausschneiden, Kopieren undEinfügen in UModel Diagramme.
EinfügenEntweder über die Tastenkürzel Strg+V, den Befehl "Einfügen" aus dem Kontextmenü oderdem gleichnamigen Befehl aus dem Menü "Bearbeiten". Fügt immer ein neues Modellelementzum Diagramm und zur Modellstruktur hinzu. Nähere Informationen siehe "Ausschneiden,Kopieren und 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 ausder Klasse 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.
© 2010 Altova GmbH
Bearbeiten 365UModel Referenz
Altova UModel 2010
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 Diagrammen jedem der drei Modell-Struktur-Fenster: auf den Registern Modell-Struktur,
Diagramm-Struktur und Favoriten. dem Register "Dokumentation" des Fensters "Übersicht".
366 UModel Referenz Bearbeiten
© 2010 Altova GmbHAltova UModel 2010
Als Bitmap kopierenKopiert das derzeit aktive Diagramm in die Zwischenablage, von wo aus Sie es in dieApplikation Ihrer Wahl einfügen können.
Bitte beachten Sie:Diagramme werden in die System-Zwischenablage kopiert. Sie müssen sie in eineandere Applikation 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.
© 2010 Altova GmbH
Projekt 367UModel Referenz
Altova UModel 2010
14.3 Projekt
Projektsyntax überprüfen...Überprüft die UModel-Projektsyntax. Die Projektdatei wird auf mehreren Ebenen überprüft.Siehe Tabelle unten:
Ebene Überprüft, ... Meldung...
Projektebene ob mindestens eine Java Namespace Root existiert Fehler
Komponenten ob die Projektdatei / das Verzeichnis definiert ist Fehler
ob eine Realisierung vorhanden ist Fehler
Bei deaktiviertem Kontrollkästchen "Für 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"FehlendeCodedateinnamengenerieren" 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 einemCodesprachen-Namespace enthalten ist
Fehler
ob der Typ für die Eigenschaften definiert ist Fehler
ob der Typ für den Operationsparameter definiert ist Fehler
ob der Rückgabetyp für die Operation definiert ist Fehler
überprüft auf doppelte Operationen (Namen +Parametertypen)
Fehler
368 UModel Referenz Projekt
© 2010 Altova GmbHAltova UModel 2010
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-Typnamenhat
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 derJava-Codegenerierung sind. Nähere Informationen dazu siehe "Einschränken vonModellelementen".
VersionskontrolleUModel unterstützt nun Microsoft SourceSafe und andere kompatible Speicherschnittstellen
Microsoft hat einen Eintrag in der Registrierungsdatei definiert, wo alleSCC-kompatiblen Programme sich registrieren können. UModel liest nur diesenEintrag.
© 2010 Altova GmbH
Projekt 369UModel Referenz
Altova UModel 2010
HKEY_LOCAL_MACHINE\SOFTWARE\SourceCodeControlProvider\InstalledSCCProviders
Beachten Sie außerdem, dass Versionskontroll-Plugins nicht automatisch von allenSCC-Produkten installiert werden. Lesen Sie hierzu bitte die Dokumentation zu Ihrerjeweiligen Versionskontrollsoftware.
Siehe:Versionskontrollsysteme: Hier finden Sie ausführliche Informationen und Anleitungen zuVersionskontrollservern und Clients.
370 UModel Referenz Projekt
© 2010 Altova GmbHAltova UModel 2010
Quellverzeichnis importieren...Öffnet das unten gezeigte Dialogfeld "Quellverzeichnis importieren". Ein Beispiel dazu findenSie unter "Round-Trip Engineering (Code - Modell - Code)".
© 2010 Altova GmbH
Projekt 371UModel Referenz
Altova UModel 2010
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
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 C#- undJava-Binärdateien.
XML-Schemaverzeichnis importierenÖffnet das Dialogfeld "XML-Schemaverzeichnis importieren", über das Sie alle XML-Schemasin diesem 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".
372 UModel Referenz Projekt
© 2010 Altova GmbHAltova UModel 2010
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.
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 wird
die neu hinzugefügte Klasse X aus UModel zum Code hinzugefügt wird.
© 2010 Altova GmbH
Projekt 373UModel Referenz
Altova UModel 2010
Merge UModel-Projekt aus ProgrammcodeÖffnet das Dialogfeld "Synchronisierungseinstellungen", wobei das Register "Modell vonCode" 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 wird
die neu hinzugefügte Klasse Y aus externem Code zum Modell hinzugefügt wird.
374 UModel Referenz Projekt
© 2010 Altova GmbHAltova UModel 2010
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,ist die Datei, in die die zweite Datei überführt wird. Nähere Informationen dazu finden Sie unter Zusammenführen von UModel-Projekten.
Unterprojekt inkludierenIm Lieferumfang von UModel sind mehrere Dateien inkludiert, die in ein UModel Projektinkludiert werden können. Durch Klicken auf das Register "Java" können Sie durch Auswahleiner der zur Verfügung gestellten Dateien Java lang-Klassen, Schnittstellen und Pakete in IhrProjekt inkludieren.
1. Wählen Sie Projekt | Unterprojekt inkludieren, um das Dialogfeld "Inkludieren" zuöffnen.
© 2010 Altova GmbH
Projekt 375UModel Referenz
Altova UModel 2010
2. Klicken Sie auf die zu inkludierende UModel-Projektdatei und klicken Sie auf OK.
UModel-Projekte können in andere UModel-Projekte inkludiert werden. Legen Sie dazu dieentsprechenden *.ump-Dateien in folgenden Ordnern ab:
...\UModel2010\UModelInclude, damit das Projekt auf dem Register "Basic" angezeigtwird, oder
...\UModel2010\UModelInclude\Java, damit das Projekt auf dem Register "Java"angezeigt wird.
Bitte beachten Sie:Eine Include-Datei, die alle Microsoft .NET Framework 2.0 Arten enthält, finden Sie aufdem Register C# 2.0.
So erstellen Sie ein benutzerdefiniertes Register/einen benutzerdefinierten Ordner:1. Gehen Sie zum Ordner ...\UModel2010\UModelInclude und erstellen Sie Ihren Ordner
unterhalb von ...\UModelInclude, d.h. ...\UModelInclude\myfolder.
So erstellen Sie beschreibenden Text zu einer einzelnen UModel-Projektdatei:1. Erstellen Sie eine Textdatei, die denselben Namen, wie die *.ump-Datei hat, und legen
Sie sie in denselben Ordner. Für die Datei MyModel.ump wird z.B. die beschreibende Datei MyModel.txt erstellt.
So entfernen Sie ein inkludiertes Projekt:1. Klicken Sie in der Modellstrukturansicht auf das inkludierte Paket und drücken Sie die
Entf-Taste.2. Sie werden gefragt, ob Sie mit dem Löschen fortfahren möchten.3. Klicken Sie auf OK, um die inkludierte Datei aus dem Projekt zu löschen.
Bitte beachten Sie: Um ein Projekt aus dem Dialogfeld "Inkludieren" zu löschen bzw. zu entfernen,
löschen oder entfernen Sie die Datei (MyModel).ump aus dem jeweiligen Ordner.
376 UModel Referenz Projekt
© 2010 Altova GmbHAltova UModel 2010
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.vor der Aktualisierung des Modellcodes während der Codegenerierung behoben werdenmüssen. Warnmeldungen weisen im Allgemeinen auf Probleme hin, die auch später behobenwerden können. Fehlermeldungen und Warnmeldungen werden von der Syntaxüberprüfung,dem Compiler für die spezifische Sprache, dem UModel Parser, der die neu generierteQuelldatei liest, sowie beim Import von XMI-Dateien, generiert.
Dokumentation generierenGestattet die Generierung von Dokumentation in den Formaten HTML, Microsoft Word undRTF für das derzeit offene Projekt. Nähere Informationen dazu finden Sie unter Generieren vonUML-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 (JavaProfile.ump) und Java Lang (Java Lang.ump) werden automatisch in dem mit UModelmitgelieferten Beispiel "Bankview" zur Verfügung gestellt.
© 2010 Altova GmbH
Layout 377UModel Referenz
Altova UModel 2010
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. daszuletzt markierte 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 vonModellelementen entlang 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 anhanddes aktiven 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ößeangepasst.
Automatisches Layout:Dieser Befehl dient zum Auswählen der Art, wie Modellelemente auf demUML-Diagrammregister dargestellt werden sollen.
Mit "Zentriert" werden die Modellelemente zentriert ausgerichtet.
Bei Auswahl von "Hierarchisch" werden die Elemente nach ihrer Beziehung,übergeordneten Klasse, abgeleiteten Klasse usw. dargestellt.
Mit "Block" werden die Elemente nach Typ gruppiert in Rechteckform dargestellt.
Textlabels neu positionieren:Positioniert die Namen der (ausgewählten) Modellelemente zurück an ihre Standardposition.
378 UModel Referenz Ansicht
© 2010 Altova GmbHAltova UModel 2010
14.5 Ansicht
Mit Hilfe der Befehle in diesem Menü können Sie:
zu Registern der verschiedenen Fenster wechseln bzw. diese aktivieren
die Sortierkriterien für die Modellelemente der Register "Modell-Struktur" und"Favoriten" definieren
die Gruppierungskriterien der Diagramme auf dem Register "Diagramm-Struktur"definieren
bestimmte UML-Elemente auf den Registern "Favoriten" und "Modell-Struktur" ein-oder ausblenden
den Zoomfaktor des aktuellen Diagramms definieren
© 2010 Altova GmbH
Extras 379UModel Referenz
Altova UModel 2010
14.6 Extras
Im Menü "Extras" können Sie:
Ihre Version anpassen: Ihre eigenen Symbolleisten, Tastaturkürzel, Menüs und Makros
definieren die globalen Programmeinstellungen/optionen definieren
380 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
14.6.1 Anpassen...
Der Befehl "Anpassen" dient zum Anpassen von UModel an Ihre persönlichen Bedürfnisse.
BefehleSymbolleistenExtrasTastaturMenüOptionen
Befehle
Auf dem Register "Befehle" können Sie Ihre Menüs oder Symbolleisten anpassen.
So fügen Sie einen Befehl zu einer Symbolleiste oder einem Menü hinzu:1. Öffnen Sie dieses Dialogfeld durch Klicken auf Extras | Anpassen.2. Wählen Sie im Listenfeld "Kategorien" die Befehlskategorie aus. Die verfügbaren
Befehle werden im Listenfeld "Befehle" angezeigt.3. Klicken Sie auf einen Befehl in der Liste der Befehle und ziehen Sie ihn in ein
vorhandenes Menü bzw. eine vorhandene Symbolleiste.4. Wenn Sie den Cursor über eine Position halten, an die der Befehl gezogen werden
kann, wird ein I-Zeichen angezeigt.5. Lassen Sie die Maustaste an der Position los, an der der Befehl eingefügt werden soll.
An der Spitze des Mauszeigers erscheint beim Ziehen des Befehls eine 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 Symbolleisteoder einem 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ählenSie anschließend aus der Liste der Kontextmenüs das jeweilige Kontextmenü aus.
So löschen Sie einen Befehl oder ein Menü:1. Öffnen Sie dieses Dialogfeld durch Auswahl von Extras | Anpassen.2. Klicken Sie auf den Menüeintrag bzw. das zu löschende Symbol und ziehen Sie es mit
der Maus.3. Lassen Sie die Maustaste los, sobald das Häkchensymbol unterhalb des Mauszeigers
erscheint.Der Befehl bzw. der Menüeintrag wird aus dem Menü bzw. der Symbolleiste gelöscht.
Symbolleisten
Auf dem Register "Symbolleisten" können Sie bestimmte Symbolleisten aktivieren 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.
© 2010 Altova GmbH
Extras 381UModel Referenz
Altova UModel 2010
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önnenSie die Symbolleisten auch am linken oder rechten Rand des Hauptfensters andocken.
So aktivieren oder deaktivieren Sie eine Symbolleiste:1. Klicken Sie auf das Kontrollkästchen, um die jeweilige Symbolleiste zu aktivieren (bzw.
zu deaktivieren).
So erstellen Sie eine neue Symbolleiste:1. Klicken Sie auf die Schaltfläche Neu... und geben Sie der Symbolleiste im Dialogfeld
"Symbolleistenname" einen Namen.2. Fügen Sie über das Register Befehle des Dialogfelds "Anpassen" Befehle zur
Symbolleiste hinzu.
So setzen Sie die Menüleiste zurück
Klicken Sie auf den Menüleisteneintrag und anschließend auf die Schaltfläche Zurücksetzen, um die Menübefehle auf den Zustand
zum Zeitpunkt der Installation zurückzusetzen
So setzen Sie alle Symbolleisten- und Menübefehle zurück
Klicken Sie auf die Schaltfläche Alle zurücksetzen, um alle Symbolleistenbefehle aufden Zustand zum Zeitpunkt der Installation des Programms zurückzusetzen. Siewerden gefragt, ob alle Symbolleisten und Menüs zurückgesetzt werden sollen.
Klicken Sie auf "Ja", um den Vorgang zu bestätigen.
Textlabels zeigen:Bei Aktivierung dieser Option wird erklärender Text unterhalb der Symbolleistenbefehleangezeigt.
Extras
Ü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.
382 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
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.
© 2010 Altova GmbH
Extras 383UModel Referenz
Altova UModel 2010
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, Schnittstelleoder Enumeration die sich gerade im Fokus befindet, z.B. “C:\Temp\MySource\Class1.cs”.
Fokussierte UML-Daten – CodeprojektdateinameDer Dateiname des Codeprojekts, zu dem die gerade fokussierte UML-Klasse, Schnittstelle
384 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
oder Enumeration 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”.
Tastatur
Auf dem Register "Tastatur" können Sie Tastaturkürzel für jeden beliebigen Befehl definieren(oder ändern).
So weisen Sie einem Befehl ein neues Tastaturkürzel zu:1. Wählen Sie im Listenfeld "Kategorie" die Befehlskategorie aus.2. Wählen Sie in der Liste "Befehle" den Befehl aus, dem Sie ein neues Tastaturkürzel
zuweisen möchten.3. Klicken Sie in das Textfeld "Tastaturkürzel eingeben:" und drücken Sie die Tasten,
mit denen dieser Befehl aufgerufen werden soll.Die Tastenkombination wird sofort im Textfeld angezeigt. Falls dieseTastenkombination bereits zugewiesen wurde, so wird diese Funktion unterhalb desTextfelds 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 derSteuerungstasten: Strg, ALT oder Umschalttaste.)
So heben Sie eine Tastenzuweisung auf (oder löschen ein Tastaturkürzel):1. Klicken Sie in der Liste "Aktuelle Tasten" auf das zu löschende Tastaturkürzel.2. Klicken Sie auf die jetzt aktiv gewordene Schaltfläche Entfernen.3. Klicken Sie auf die Schaltfläche "Schließen", um alle im Dialogfeld "Anpassen"
vorgenommenen Änderungen zu bestätigen.
Menü
Auf dem Register "Menü" können Sie die Hauptmenüleisten sowie die Kontextmenüs(Rechtsklickmenüs) anpassen.
Sie können sowohl die Standard- als auch die UModel-Projekt-Menüleiste anpassen.Das Standardmenü ist das Menü, das angezeigt wird, wenn keine XML-Dokumente
irgendeiner Art geöffnet sind.Das UModel Projektmenü ist die Menüleiste, die angezeigt wird, wenn eine *.ump-Datei
geöffnet ist.
So passen Sie ein Menü an:1. Wählen Sie die gewünschte Menüleiste aus dem Listenfeld "Menüs anzeigen für" aus.2. Klicken Sie auf das Register Befehle und ziehen Sie die Befehle in die Menüleiste Ihrer
Wahl.
So löschen Sie Befehle aus einem Menü:1. Rechtsklicken Sie auf den Befehl oder das Symbol für den Befehl und2. Wählen Sie die Option Löschen aus dem Popup-Menü aus.
© 2010 Altova GmbH
Extras 385UModel Referenz
Altova UModel 2010
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üschatten
Klicken Sie auf das Kontrollkästchen "Menüschatten", wenn die Menüs mit Schattenangezeigt werden sollen.
Optionen
Auf dem Register "Optionen" können Sie allgemeine Einstellungen vornehmen.
SymbolleisteWenn das Kontrollkästchen "Tooltip in Symbolleiste einblenden" aktiv ist, wird ein Popupangezeigt, wenn der Mauszeiger über ein Symbol in einer der Symbolleisten platziert wird. Indiesem Popup wird eine kurze Beschreibung der Funktion des Symbols angezeigt sowie dasdazugehörige Tastaturkürzel, falls eines zugewiesen wurde.
Mit Hilfe des Kontrollkästchens Tastaturkürzel in Tooltip anzeigen können Sie festlegen, obdas Tastaturkürzel im Tooltipp angezeigt werden soll.
Wenn das Kontrollkästchen Große Symbole aktiv ist, werden anstatt der Standardsymbolegrößere Symbole angezeigt.
386 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
14.6.2 Optionen
Wählen Sie den Menüeintrag Extras | Optionen, um Ihre Projektoptionen zu definieren.
Auf dem Register Ansicht können Sie folgende Einstellungen festlegen: wo das Programmlogo angezeigt werden soll. den Inhalt der Applikationstitelleiste die Elementarten, die aufgelistet werden sollen, wenn Sie auf dem Register
"Model-Struktur" oder "Favoriten" auf die Kontextmenüoption "In keinem Diagrammverwendete Elemente auflisten" klicken. Sie haben auch die Möglichkeit, Elemente in inkludierten Dateien zu ignorieren.
ob ein in einem Diagramm ausgewähltes Element in der Modell-Struktur 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 kannnur eines derselben Classifier-Elemente erweitert werden.
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
© 2010 Altova GmbH
Extras 387UModel Referenz
Altova UModel 2010
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.
388 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
Auf dem Register Diagrammbearbeitung können Sie folgende Einstellungen definieren: wieviele Objekte automatisch zu einem Diagramm hinzugefügt werden können, bevor
eine Eingabeaufforderung erscheint. die Anzeige von Stilen, wenn diese automatisch zu einem Diagramm hinzugefügt
werden. ob automatisch Assoziationen zwischen Modellelementen erstellt werden sollen, wenn
Elemente zu einem Diagramm hinzugefügt werden. ob die Assoziationen zu Collections aufgelöst werden sollen. ob Vorlagen von unbekannten externen Elementen als nicht vollständig qualifiziert
aufgelöst werden sollen. ob bestehende Collection-Vorlagen verwendet oder neue definiert werden sollen.
Collection-Vorlagen sollten als voll qualifiziert definiert werden, also a.b.c.List. Wenn dieVorlage diesen Namespace hat, erstellt UModel automatisch eineCollection-Assoziation. Ausnahme: Wenn die Vorlage zum Paket der unbekanntenexternen Elemente gehört und die Option "Unbekannte externe Elemente: nichtqualifizierte 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 oderOperationen im Klassendiagramm verfügbar sein soll.
Auf dem Register Datei können Sie folgende Einstellungen definieren: welche Aktionen durchgeführt werden sollen, wenn Dateien geändert werden. ob der Inhalt des Registers "Favoriten" sowie alle derzeit offenen Diagramme mit dem
© 2010 Altova GmbH
Extras 389UModel Referenz
Altova UModel 2010
aktuellen Projekt geladen und gespeichert werden soll. ob das zuletzt geöffnete Projekt beim Starten der Applikation automatisch geöffnet
werden soll. ob die Projektdatei mit CR/LF-Zeilen und Tabulatoreinrückungen im Pretty-Print-Format
gespeichert werden soll.
390 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
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 weden 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.
392 UModel Referenz Extras
© 2010 Altova GmbHAltova UModel 2010
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, jenachdem, 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 derDialogfelder die Option "Wenn Dialogfelder mit "..nicht mehr anzeigen" ausgeblendetwaren, klicken Sie auf "Zurücksetzen", damit sie wieder angezeigt werden" aktivierthaben. Daraufhin wird diese "nicht mehr anzeigen"-Meldung wieder angezeigt.
© 2010 Altova GmbH
Fenster 393UModel Referenz
Altova UModel 2010
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 nebeneinanderangeordnet, 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 desunteren Rands des Diagrammansichtsbereichs positioniert.
Schließen:Schließt das derzeit aktive Diagrammregister.
Alle schließen:Schließt alle derzeit geöffneten Diagrammregister.
Alle bis auf das aktive schließen:Schließt alle Diagrammregister mit Ausnahme des derzeit aktiven.
Nächstes:Wechselt zum nächsten Modelldiagrammregister in der Reihe der Register oder zum nächstenHyperlink-Element.
Vorheriges:Wechselt zum vorherigen Modelldiagrammregister in der Reihe der Register oder zumvorherigen Hyperlink-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.
394 UModel Referenz Hilfe
© 2010 Altova GmbHAltova UModel 2010
14.8 Hilfe
Über diesen Befehl können Sie das Inhaltsverzeichnis und den Index der UModelDokumentation aufrufen, sowie die Links zur Altova Website. Über die Option "Registrieren"wird der Altova Lizenzierungsmanager geöffnet, der die Lizenzinformationen für alleAltova-Produkte enthält.
396 Code Generator
© 2010 Altova GmbHAltova UModel 2010
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önnenSie jetzt 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 Aliasdefinitionensind die Dateien, in denen diese vorkommen.
z.B. using Q = System.Collections.Generic.Queue<String>;Q myQueue;
Aliasse, bei denen es potentiell zu einem Konflikt kommen kann, werden zu den "unbekanntenexternen Elementen" hinzugefügt, wenn ihre Verwendung nicht klar ist.
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 397Code Generator
Altova UModel 2010
15.1 Der Weg zu 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 mitOperatoren, Funktionen, Variablen und Klassen sowie den Grundzügen von in SPl häufigverwendeter objektorientierter Programmierung vertraut sind.
Im Ordner ...\UModelspl finden Sie die von UModel verwendeten Vorlagen. Anhand dieserDateien 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 Erstellenvon Dateien, Lesen von Informationen aus dem Objektmodell und Ausführen vonBerechnungen, die in der Zielprogrammiersprache auch Literalcodefragmente enthalten.
Die Vorlagendatei wird von Code Generator interpretiert und je nach Vorlage wird eine .cpp,.java, .cs Quellcodedatei oder eine andere Dateiart ausgegeben.
398 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
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 ']'. Innerhalbeiner Klammer können mehrere Anweisungen stehen. Zusätzliche Anweisungen müssen durcheine neue Zeile oder einen Doppelpunkt ':' getrennt werden.
Gültige Beispiele sind:
[$x = 42 $x = $x + 1]
or
[$x = 42: $x = $x + 1]
Hinzufügen von Text zu 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 undenden an der nächsten Zeile oder an einem Zeichen, zum Beenden eines Blocks ].
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 399Code Generator
Altova UModel 2010
15.1.2 Variablen
Jede etwas komplexere SPL-Datei enthält Variablen. Einige Variablen sind vom CodeGenerator vordefiniert. Sie können jederzeit neue Variablen erstellen, indem Sie diesen Wertezuweisen.
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 anderen
Werte true. String Objekt - wird von UModel bereitgestellt Iterator (siehe foreach-Anweisung)
Variablentypen werden durch die erste Zuweisung deklariert.
[$x = 0] x ist nun ein Integer.
[$x = "teststring"] x wird nun als String behandelt.
Strings:String-Konstanten müssen wie im oben gezeigten Beispiel immer innerhalb von doppeltenAnführungszeichen stehen. \n und \t innerhalb von doppelten Anführungszeichen werden alsneue Zeile und Tabulator interpretiert, \" ist ein literales doppeltes Anführungszeichen und \\ istein umgekehrter 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 habenEigenschaften, die über den . Operator aufgerufen werden können. In SPL können keineneuen Objekte erstellt werden (sie werden durch den Code Generator vordefiniert, aus derInput-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 ihrenSPL-Entsprechungen sowie eine kurze Beschreibung dazu.
400 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
Vordefinierte Variablen
UML-Element SPL-Eigenschaft
Multiplizität
UML UModel Beschreibung
Attribute / Association
Attribute / Association
BehavioralFeature isAbstract isAbstract:Boolean
BehavioralFeature raisedException
* raisedException:Type
BehavioralFeature ownedParameter
* ownedParameter:Parameter
BehavioredClassifier
interfaceRealization
* interfaceRealization:InterfaceRealization
Class ownedOperation
* ownedOperation:Operation
Class nestedClassifier
* nestedClassifier:Classifier
Classifier namespace * namespace:Package
packages with codelanguage<<namespace>> set
Classifier rootNamespace
* project rootnamespace:String
VB only - rootnamespace
Classifier generalization * generalization:Generalization
Classifier isAbstract isAbstract:Boolean
ClassifierTemplateParameter
constrainingClassifier
* constrainingClassifier
Comment body body:String
DataType ownedAttribute
* ownedAttribute:Property
DataType ownedOperation
* ownedOperation:Operation
Element kind kind:String
Element owner 0..1 owner:Element
Element appliedStereotype
* appliedStereotype:StereotypeApplication
applied stereotypes
Element ownedComment
* ownedComment:Comment
ElementImport importedElement
1 importedElement:PackageableElement
Enumeration ownedLiteral * ownedLiteral:EnumerationLiteral
Enumeration nestedClassifier
* nestedClassifier::Classifier
Enumeration interfaceRealization
* interfaceRealization:Interface
EnumerationLiteral
ownedAttribute
* ownedAttribute:Property
EnumerationLiteral
ownedOperation
* ownedOperation:Operation
EnumerationLiteral
nestedClassifier
* nestedClassifier:Classifier
Feature isStatic isStatic:Boolean
Generalization general 1 general:Classifier
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 401Code Generator
Altova UModel 2010
Interface ownedAttribute
* ownedAttribute:Property
Interface ownedOperation
* ownedOperation:Operation
Interface nestedClassifier
* nestedClassifier:Classifier
InterfaceRealization
contract 1 contract:Interface
MultiplicityElement
lowerValue 0..1 lowerValue:ValueSpecification
MultiplicityElement
upperValue 0..1 upperValue:ValueSpecification
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 namespacePrefix
namespacePrefix:String
XSD only - namespaceprefix when exists
NamedElement parseableName
parseableName:String
CSharp, VB only - namewith escaped keywords(@)
Namespace elementImport
* elementImport:ElementImport
Operation ownedReturnParameter
0..1 ownedReturnParameter:Parameter
parameter with directionreturn set
Operation type 0..1 type type of parameter withdirection return set
Operation ownedOperationParameter
* ownedOperationParameter:Parameter
all parameters excludingparameter with directionreturn set
Operation implementedInterface
1 implementedInterface:Interface
CSharp only - theimplemented interface
Operation ownedOperationImplementations
* implementedOperation:OperationImplementation
VB only - theimplementedinterfaces/operations
OperationImplementation
implementedOperationOwner
1 implementedOperationOwner:Interface
interface implementedby the operation
OperationImplementation
implementedOperationName
name:String name of theimplemented operation
OperationImplementation
implementedOperationParseableName
parseableName:String
name of theimplemented operationwith esacped keywords
Package namespace * namespace:Package
packages with codelanguage<<namespace>> set
PackageableElement
owningPackage
0..1 owningPackage set if owner is apackage
PackageableElement
owningNamespacePackage
0..1 owningNamespacePackage:Package
owning package withcode language<<namespace>> set
Parameter direction direction:ParameterDirectionKind
402 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
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:Boolean
true if parameter is avariable argument list
Parameter defaultValue 0..1 defaultValue:ValueSpecification
Property defaultValue 0..1 defaultValue:ValueSpecification
RedefinableElement
isLeaf isLeaf:Boolean
Slot name name:String name of the definingfeature
Slot values * value:ValueSpecification
Slot value value:String value of the first valuespecification
StereotypeApplication
name name:String name of appliedstereotype
StereotypeApplication
taggedValue * taggedValue:Slot first slot of the instancespecification
StructuralFeature isReadOnly isReadOnly
StructuredClassifier
ownedAttribute
* ownedAttribute:Property
TemplateBinding signature 1 signature:TemplateSignature
TemplateBinding parameterSubstitution
* parameterSubstitution:TemplateParameterSubstitution
TemplateParameter
paramDefault paramDefault:String template parameterdefault value
TemplateParameter
ownedParameteredElement
1 ownedParameteredElement:ParameterableElement
TemplateParameterSubstitution
parameterSubstitution
parameterSubstitution:String
Java only - codewildcard handling
TemplateParameterSubstitution
parameterDimensionCount
parameterDimensionCount:Integer
code dimension count ofthe actual parameter
TemplateParameterSubstitution
actual 1 OwnedActual:ParameterableElement
TemplateParameterSubstitution
formal 1 formal:TemplateParameter
TemplateSignature
template 1 template:TemplateableElement
TemplateSignature
ownedParameter
* ownedParameter:TemplateParameter
TemplateableElement
isTemplate isTemplate:Boolean true if templatesignature set
TemplateableElement
ownedTemplateSignature
0..1 ownedTemplateSignature:TemplateSignature
TemplateableElement
templateBinding
* templateBinding:TemplateBinding
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 403Code Generator
Altova UModel 2010
Type typeName * typeName:PackageableElement
qualified code typenames
TypedElement type 0..1 type:Type
TypedElement postTypeModifier
postTypeModifier:String
postfix code modifiers
ValueSpecification value value:String string value of the valuespecification
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 Verwendund 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 Siesicher, dass sie bei Installation einer neuen Version von UModel nicht überschrieben werden.Stellen Sie bitte sicher, dass Sie im Dialogfeld "Synchronisierungseinstellungen" auf demRegister Code von Modell das Kontrollkästchen "Benutzerdefinierte setzt Standardvorlageaußer Kraft" aktiviert haben.
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 Anzeigeder aktuellen Verschachtelungsebene.
$IndentStep ein String zum Einrücken von generiertem Code und zurDarstellung einer Verschachtelungsebene.
$NamespacePrefix nur XSD – das Target Namespace Präfix, falls vorhanden
Routinen zur Behandlung von Stringsinteger Find( s )Durchsucht den String nach der ersten Instanz eines Substring s.Gibt den nullbasieren Index des ersten Zeichens von s oder -1 zurück, wenn s nicht gefundenwird.
string Left( n )Gibt die ersten n Zeichen des String zurück.
404 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
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 Substrings entspricht. string RemoveLeftNoCase( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Left( s.Length() ) dem Substrings entspricht (Groß- und Kleinschreibung wird ignoriert).
string RemoveRight( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substrings entspricht.
string RemoveRightNoCase( s )Gibt einen String zurück, der den Substring s ausnimmt, wenn Right( s.Length() dem Substrings entspricht (Groß- und Kleinschreibung wird ignoriert).
string Repeat( s, n )Gibt einen String zurück, der den Substring s n mal enthält.
string Right( n )Gibt die letzten n Zeichen des String zurück.
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 405Code Generator
Altova UModel 2010
15.1.3 Operatoren
Operatoren in SPL funktionieren wie in den meisten anderen Programmiersprachen.
Liste von SPL-Operatoren absteigend nach Vorrangigkeit gereiht:
. 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
406 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
15.1.4 Bedingungen
SPL erlaubt die Verwendung von Standard-"if"-Anweisungen. Die Syntax lautet wie folgt:
if conditionstatements
elsestatements
endif
or, without else:
if conditionstatements
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 undVergleichsoperatoren 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.
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 407Code Generator
Altova UModel 2010
15.1.5 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 collectionstatements
next
Beispiel:[foreach $class in $classes
if not $class.IsInternal] class [=$class.Name];
[ endifnext]
Foreach iteriert durch alle Datenelemente in $classes und führt für die Anweisung den Codeder auf die Anweisung folgt, bis zur nächsten Anweisung aus.
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 0IsFirst 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]
408 Code Generator Der Weg zu SPL (Spy Programming Language)
© 2010 Altova GmbHAltova UModel 2010
15.1.6 Subroutinen
Code Generator unterstützt nun Subroutinen in der Form von Prozeduren oder Funktionen.
Funktionen: Übergabe von Werten nach Wert und nach Referenz Lokale/globale Parameter (lokal innerhalb von Subroutinen) Lokale Variablen Rekursiver Aufruf (Subroutinen können sich selbst aufrufen)
Deklaration einer Subroutine
Subroutinen
Syntax-Beispiel:
Sub SimpleSub()
... lines of code
EndSub
Sub ist das Schlüsselwort, das die Prozedur notiert. SimpleSub ist der Name, der der Subroutine zugewiesen wurde. Runde Klammern können eine Parameterliste enthalten. Der Code-Block einer Subroutine beginnt direkt nach der geschlossenen Klammer
nach dem Parameter. EndSub notiert das Ende des Code-Blocks.
Bitte beachten Sie:Eine rekursive oder kaskadierende Subroutine-Deklaration ist nicht zulässig, d.h. eineSubroutine darf keine weiteren Subroutinen enthalten.
ParameterParameter können auch durch Prozeduren unter Verwendung der folgenden Syntax übergebenwerden:
Alle Parameter müssen Variablen sein Variablen muss das $-Zeichen vorangestellt werden Lokale Variablen werden in einer Subroutine definiert Globale Variablen werden explizit außerhalb von Subroutinen deklariert Mehrere Parameter werden innerhalb runder Klammern durch Kommas "," voneinander
getrennt Parameter können Werte übergeben
Parameter - Übergabe von WertenParameter können auf zwei Arten übergeben werden: nach Wert oder nach Referenz, wobei dieSchlüsselwörter ByVal bzw. ByRef verwendet werden.
Syntax:' define sub CompleteSub()[Sub CompleteSub( $param, ByVal $paramByValue, ByRef $paramByRef )] ...
© 2010 Altova GmbH
Der Weg zu SPL (Spy Programming Language) 409Code Generator
Altova UModel 2010
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]
Subroutinenaufruf
Verwenden Sie zum Aufrufen einer Subroutine call, gefolgt vom Namen der Prozedur und ggf.den Parametern.
Call SimpleSub()oder,
Call CompleteSub( "FirstParameter", $ParamByValue, $ParamByRef )
FunktionsaufrufUm eine Funktion (jede Subroutine, die ein Return-Statement enthält) aufzurufen, verwendenSie einfach deren Namen in einem Ausdruck. Verwenden Sie zum Aufrufen von Funktionennicht das Call-Statement.Beispiel:$QName = MakeQualifiedName($namespace, "entry")
410 Code Generator Fehlercodes
© 2010 Altova GmbHAltova UModel 2010
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 Ingültiger Parameter510 Division durch Null511 Unbekannte Methode512 Falsche Parameteranzahl513 Stapelüberlauf
412 Anhänge
© 2010 Altova GmbHAltova UModel 2010
16 Anhänge
Die Anhänge enthalten technische Informationen zu UModel sowie wichtigeLizenzierungsinformationen.
Lizenzinformationen
Electronic software distribution Copyrights Endbenutzerlizenzvereinbarung (EULA)
© 2010 Altova GmbH
Lizenzinformationen 413Anhänge
Altova UModel 2010
16.1 Lizenzinformationen
Dieser Anhang enthält die folgenden Informationen: Informationen über den Vertrieb dieses Software-Produkts Informationen im Zusammenhang mit dem intellektuellen Eigentum dieses
Software-Produkts Die 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.
414 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
16.1.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 Bestellung
online abgeben und das Produkt steht Ihnen in Minutenschnelle im vollen Lizenzumfangzur Verfügung. Sie erhalten immer die neueste Version unserer Software Die Software enthält ein umfassendes Online-Hilfesystem. Die neueste Version des
Benutzerhandbuchs steht auf unserer Website www.altova.com (i) im HTML-Format 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 Software-Produktlizenz erwerben, die Sie in Formeines Keycodes erhalten, der in das Dialogfeld "Software-Aktivierung" eingegeben werdenmuss, um das Produkt zu aktivieren. Sie können Ihre Lizenz online in unserem Web-Shopunter Altova Shop 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.
© 2010 Altova GmbH
Lizenzinformationen 415Anhänge
Altova UModel 2010
16.1.2 Software-Aktivierung und Lizenzüberwachung
Im Rahmen der Aktivierung der Software durch Altova, verwendet die Software unterUmständen Ihr internes Netzwerk und Ihre Internetverbindung, um die Lizenzdaten während derInstallatoin, Registrierung, der Verwendung oder der Aktualisierung an einen von Altovabetriebenen Lizenzserver 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 werdenkann und um den Kundenservice gleichzeitig zu verbessern. Bei der Aktivierung werdenzwischen Ihrem Computer und dem Altova-Lizenzserver für die Lizenzierung erforderlicheDaten wie Informationen über Betriebssystem, IP-Adresse, Datum/Uhrzeit, Software-Versionund Computername sowie andere 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 nachLizenz stellt das Lizenzüberwachungsmodul sicher, dass nicht mehr als die lizenzierte Anzahlan Benutzern 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 Datagramabgesendet, um andere Instanzen des Produkts, die auf anderen Computern im selbenNetzwerk 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 vonParallellizenzen für mehrere Benutzer zu vernünftigen Preisen.
Wir sind außerdem bestrebt, nur wenige, kleine Netzwerkpakete zu versenden, um IhrNetzwerk nicht zu überlasten. Die von Ihrem Altova Produkt verwendeten TCP/IP Ports (2799)sind offiziell bei IANA registriert, (nähere Informationen siehe http://www.isi.edu/in-notes/iana/assignments/port-numbers) und unserLizenzüberwachungsmodul basiert auf einer bewährten und getesteten Technologie.
Wenn Sie eine Firewall verwenden, werden Sie unter Umständen feststellen, dass dieComputer, auf denen Altova-Produkte laufen, über Port 2799 miteinander kommunizieren. Siekönnen diesen Netzwerkverkehr zwischen verschiedenen Gruppen in Ihrem Unternehmennatürlich blockieren, solange Sie mit anderen Mitteln sicherstellen können, dass IhreLizenzvereinbarung eingehalten wird.
Sie werden außerdem auch feststellen, dass Ihr Altova Produkt viele nützliche Funktionenenthält, die Ihre Internet-Verbindung verwenden, diese stehen jedoch nicht mit derLizenzüberwachungsfunktion in Zusammenhang.
416 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
16.1.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 Informationenvon Altova 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 dasin den 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 alle dazugehörigen Unterlagen in gedruckter Form. Mitteilungen über geltend gemachteVerstöße gegen geistige Eigentumsrechte sind an den Copyright Agenten von Altova zu richten(nähere Angaben dazu finden Sie auf der Website von Altova).
Altova Software enthält Software-Komponenten Dritter, die ebenfalls urheberrechtlich geschü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.
© 2010 Altova GmbH
Lizenzinformationen 417Anhänge
Altova UModel 2010
16.1.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 („Lizenzvertrag“) ist ein rechtsgültiger Vertrag,
der zwischen Ihnen und Altova GmbH („Altova“) abgeschlossen wurde. Bevor Sie die
von Altova bereitgestellte Software („Software“) sowie die dazugehörige Dokumentation
(u.a. Unterlagen in gedruckter Form, Online-Dateien oder Dokumentation in
elektronischer Form („Dokumentation“)) verwenden, lesen Sie bitte dieses Dokument
sorgfältig durch. Indem Sie auf die untenstehenden Schaltflächen „Ich akzeptiere“ und
„Weiter“ klicken, oder indem Sie die Software installieren oder auf sonstige Weise
nutzen, stimmen Sie zu, dass Sie die Bedingungen dieses Lizenzvertrags sowie die
Datenschutzbestimmungen („Datenschutzbestimmungen“) von Altova, inklusive, jedoch
nicht ausschließlich, die nachfolgend festgelegten Garantieausschlüsse,
Haftungsbeschränkungen sowie Datennutzungs- und Kündigungsregelungen als
rechtsverbindlich anerkennen, auch wenn Sie die Software nicht käuflich erwerben. Sie
stimmen zu, dass diese Vereinbarung in demselben Umfang gültig und durchsetzbar ist,
wie ein von Ihnen persönlich unterzeichneter Vertrag. Wenn Sie den Bedingungen dieses
Lizenzvertrags nicht zustimmen, sind Sie nicht zur Verwendung der Software berechtigt und
müssen alle heruntergeladenen Kopien, die sich in Ihrem Besitz oder unter Ihrer Kontrolle
befinden, vernichten. Während des Installationsvorganges können Sie eine Kopie dieses
Lizenzvertrages zum Zeitpunkt Ihrer Zustimmung ausdrucken. Darüber hinaus können Sie
unsere Website unter http://www.altova.com/eula besuchen, um eine Kopie dieses
Lizenzvertrags herunterzuladen und auszudrucken und um die Datenschutzbestimmungen
einzusehen.
1. SOFTWARELIZENZ
(a) Lizenzgewährung.
(i) Sofern Sie diesem Lizenzvertrag zugestimmt haben, gewährt Ihnen Altova eine
nicht ausschließliche und nicht übertragbare (mit Ausnahme der nachfolgenden
Bestimmungen) Lizenz, ohne das Recht zur Vergabe von Sublizenzen, zur Installation und
Verwendung der Software auf einem kompatiblen Einzelplatzrechner oder einer Workstation,
wobei die maximale Zahl an Computern, die im Lizenzumfang enthalten sind, nicht
überschritten werden darf. Vorbehaltlich der Beschränkungen gemäß Abschnitt 1 (c), dürfen Sie
eine Kopie der Software auf mehr als einem Ihrer kompatiblen Einzelplatzrechnern oder
418 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
Workstations installieren und verwenden, wenn Sie eine Named-User-Lizenz erworben haben.
Diese maximale Zahl an Computern und/oder Benutzern wird beim Kauf der Software
festgelegt und genau angegeben. Während des Evaluierungszeitraums (wie nachfolgend
definiert) darf die Software nur von einem Benutzer und auf nur einem Einzelplatzrechner oder
einer Workstation installiert und genutzt werden.
Wenn Sie die Lizenz im Rahmen eines Pakets von Altova-Softwareprodukten („Produktpaket“)
erworben haben, von denen Sie nicht jedes Produkt einzeln installiert haben, gelten die
Bestimmungen dieses Lizenzvertrags für die Verwendung der gesamten Software, die im
Lieferumfang des Produktpakets enthalten ist.
(ii) Wenn Sie eine Lizenz für SchemaAgent erworben haben, dann gelten die
Bestimmungen dieses Lizenzvertrags zur Nutzung der Software für den darin inkludierten
SchemaAgent-Server („SchemaAgent-Server“). Dabei dürfen Sie den SchemaAgent-Server
jedoch ausschließlich in Verbindung mit der Altova-Software und nur für die in der
dazugehörigen Dokumentation beschriebenen Zwecke verwenden.
(iii) Wenn Sie eine Lizenz für Altova Software erworben haben, die es dem Benutzer
ermöglicht den Quellcode zu generieren, dann sind Sie durch die Ihnen im Rahmen dieser
Lizenz erteilten Genehmigung zur Installation und Verwendung der Software auch berechtigt,
den Quellcode zu generieren, und zwar entweder (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), oder (ii) anhand Ihrer eigenen Schemata oder Mappings (der anhand
Ihres eigenen Quellmaterials generierte Code wird als „unbeschränkter Quellcode“ bezeichnet).
Zusätzlich zu den durch diesen Lizenzvertrag eingeräumten Rechten gewährt Ihnen Altova eine
nicht ausschließliche, nicht übertragbare und eingeschränkte Lizenz, den gesamten generierten
Code (bestehend aus dem beschränkten und unbeschränkten Quellcode) in eine ausführbare
Objektcodeform zu übersetzen und diese zu verwenden, zu kopieren, weiterzugeben oder zu
lizenzieren. Sie sind nur dann befugt, den beschränkten Quellcode ab- oder weiterzugeben,
weiterzulizenzieren, zu verkaufen oder an Dritte zu übertragen, wenn die betreffende Partei
bereits in Form eines gesonderten Lizenzvertrags oder einer anderen Vereinbarung mit Altova
zur Verwendung des beschränkten Quellcodes berechtigt ist. Ungeachtet anderslautender
Bestimmungen in diesem Lizenzvertrag, dürfen Sie die Altova-Library-Module oder den
beschränkten Quellcode (oder sonstiges geistiges Eigentum von Altova enthalten in oder in
Verbindung mit den Altova-Library-Modulen oder dem beschränkten Quellcode) nicht in solcher
Art und Weise weitergeben, in andere Software einbetten, mit anderer Software verbinden oder
auf andere Weise verwenden, die den beschränkten Quellcode den Bestimmungen des
„Copylefts“, der freien Software oder einer Open Source Lizenz unterwerfen würde, welche die
Offenlegung des beschränkten Quellcodes oder der Altova-Library-Module erforderlich machen
würde.
Altova behält sich alle übrigen Rechte an der Software vor. Bei den Bestandteilen von UModel,
für die ein Reverse Engineering Ihres eigenen oder eines anderen Quellcodes, den Sie
rechtmäßig erworben haben, zulässig ist, stellt eine solche Verwendung durch Sie keinen
Verstoß gegen diesen Lizenzvertrag dar. Soweit dies nicht in Abschnitt 1(h) ausdrücklich
gestattet wird, ist ein Reverse Engineering der Software explizit untersagt.
(b) Verwendung auf einem Server. Sie sind berechtigt, ein Exemplar der
Software auf einem Dateiserver ausschließlich innerhalb Ihres internen Netzwerks zu
installieren und von dort auf die maximale Zahl von betrieblich genutzten Computern innerhalb
© 2010 Altova GmbH
Lizenzinformationen 419Anhänge
Altova UModel 2010
dieses Netzwerks, die in der Lizenz angegeben ist, herunterzuladen und zu installieren. Wenn
Sie eine Lizenz für SchemaAgent erworben haben, können Sie SchemaAgent auf jedem Server
oder jeder Workstation installieren und in Verbindung mit Ihrer Software verwenden. Jede
sonstige Netzwerknutzung ist unzulässig; dies umfasst insbesondere die direkte Verwendung
oder die Nutzung der Software über Befehle, Daten oder Anweisungen von oder an einen
Computer, der nicht Teil Ihres internen Netzwerks ist, die Verwendung für Internet- oder
Webhosting-Dienste sowie die Verwendung durch einen Benutzer, der nicht unter einer gültigen
Lizenz von Altova zur Verwendung dieses Exemplars der Software berechtigt ist. Wenn Sie
eine Parallellizenz im Sinne von Abschnitt 1(d) und unter den dort vorgesehenen
Einschränkungen erworben haben, sind Sie berechtigt, ein Exemplar der Software auf einem
Terminalserver (Microsoft Terminal Server, Citrix Metraframe, usw.) oder einem
Anwendungsvirtualisierungsserver (Microsoft App-V, Citrix XenApp, VMWare ThinApp, usw.) in
Ihrem Intranet zu installieren, damit einzelne Benutzer in Ihrer Organisation von einem anderen
Computer innerhalb des gleichen physischen Netzwerks auf die Software zugreifen und diese
nutzen können. Jedoch darf die Zahl der Benutzer, die über einen Netzwerk- oder
Terminalserver auf die Software zugreifen, die maximale Zahl der im Lizenzumfang enthaltenen
User nicht überschreiten. Altova gibt über die Performance der Altova-Software in einer
Terminalserver-Umgebung keinerlei Zusicherungen oder Gewährleistungen ab. Die Anwendung
der Altova-Software auf die vorstehend beschriebene Weise ist ausdrücklich von der
eingeschränkten Garantie, die durch Abschnitt 5 dieses Lizenzvertrags eingeräumt wird,
ausgeschlossen. Ebenso wird kein technischer Support bei Problemen geleistet, die aufgrund
der Anwendung in einer solchen Umgebung auftreten.
(c) Benutzerdefinierte Nutzung. Wenn Sie eine Lizenz der benutzerdefinierten
Version der Software erworben haben, sind Sie berechtigt, die Software auf bis zu 5
kompatiblen Einzelplatzrechnern oder Workstations zu installieren, auf denen Sie der primäre
Nutzer sind. Dadurch können Sie von einem Computer zu einem anderen je nach dem Bedarf
wechseln, vorausgesetzt, dass die Software von Ihnen als benutzerdefinierter Nutzer jeweils nur
einmal gleichzeitig verwendet wird. Wenn Sie mehrere benutzerdefinierte Lizenzen erworben
haben, erhält jeder individuell definierte Nutzer einen gesonderten Lizenzschlüssel.
(d) Parallellizenz. Wenn Sie eine Software-Version für Parallelbenutzer
erworben haben, können Sie die Software auf mehreren kompatiblen und betrieblich genutzten
Computern installieren, jedoch höchstens zehnmal (10-mal) die maximale Zahl der Benutzer,
vorausgesetzt, dass nur die maximale Zahl von Benutzern die Software wirklich gleichzeitig
nutzen sowie weiters vorausgesetzt, dass die Computer, auf welchen die Software installiert ist,
in dasselbe physische Computer Netzwerk eingebunden sind. Die maximale Zahl der
Parallelbenutzer wird beim Kauf der Software festgelegt. Sofern die Parallelbenutzer Version
der Software an mehr als einem Standort oder in mehr als einem Netzwerk verwendet werden
soll, sind für jedes physisch getrennte Netzwerk sowie für jeden physisch getrennten Standort
separate Parallelbenutzer Lizenzen erforderlich, wobei die Einschränkungen hinsichtlich der
maximalen Zahl der Benutzer und die Anzahl der Nutzer, die die Software benutzen oder
Zugang zur Software benötigen, anwendbar sind. Für den Fall, dass ein Computer nicht in
dasselbe physische Netzwerk eingebunden ist, ist für diesen eine lokal installierte
Benutzerlizenz erforderlich. Be- und Einschränkungen hinsichtlich der Nutzung von
Parallelbenutzer Lizenzen auf Heimcomputern sind in Abschnitt 1(e) geregelt.
420 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
(e) Kopien für Sicherungs- und Archivierungszwecke. Sie dürfen eine Kopie
der Software für Sicherungs- und eine Kopie für Archivierungszwecke herstellen, sofern diese
nicht auf einem Computer installiert oder verwendet werden. Außerdem müssen bei Kopien zu
Sicherungs- und Archivierungszwecken alle im Original enthaltenen urheber- und
patentrechtlichen Angaben sowie alle anderen Angaben hinsichtlich geistiger Eigentumsrechte
von Ihnen reproduziert werden und in der jeweiligen Kopie der Software unverändert enthalten
sein. Die Befugnis zum Anlegen einer Sicherungs- und Archivierungskopie darf nur an Dritte
übertragen werden, wenn gleichzeitig eine Übertragung aller Rechte an der Software gemäß
Abschnitt 3 erfolgt.
(f) Nutzung auf dem Privat-PC (privater und nicht-kommerzieller Gebrauch).
Um sich mit der Software, ihren Features und Funktion besser vertraut zu machen, sind Sie als
vorrangiger Benutzer des Computers, auf dem die Software installiert wurde, berechtigt, ein
weiteres Exemplar der Software zum persönlichen und nicht kommerziellen Gebrauch („pnk“)
auf einem einzigen Ihrer Heimcomputer (z.B. Ihrem Laptop oder PC) zu installieren. Dieses
pnk-Exemplar darf zu keinerlei kommerziellen oder umsatzgenerierenden Geschäftsaktivitäten
verwendet werden. Dazu gehören insbesondere die Arbeit von zu Hause aus, jedwede Form
von Telearbeit oder andere Arbeit, die im Zusammenhang mit der Verwendung der Software
steht. Das pnk-Exemplar der Software darf nicht gleichzeitig auf einem Privat-PC und dem
eigentlich dafür vorgesehenen Primärcomputer verwendet werden.
(g) Freischaltcodes, Upgrades und Updates. Bevor Sie die Software kaufen
bzw. im Rahmen Ihrer Registrierung für den Evaluierungszeitraum von dreißig (30) Tagen
erhalten Sie einen Evaluierungs-Freischaltcode. Wenn Sie sich in der Folge dazu entscheiden,
die Software von Altova GmbH oder einem autorisierten Vertriebshändler zu kaufen, erhalten
Sie einen uneingeschränkten Freischaltcode. Mit diesem können Sie die Software nach dem
Evaluierungszeitraum aktivieren. Ohne ausdrückliche schriftliche Genehmigung von Altova
dürfen Sie an Freischaltcodes keine Lizenzen einräumen und Freischaltcodes nicht
reproduzieren oder vertreiben. Wenn es sich bei der Software, für die Sie eine Lizenz erworben
haben, um ein Upgrade oder ein Update handelt, so beendet das letzte Update oder Upgrade,
welches Sie heruntergeladen und installiert haben, die früher lizenzierte Kopie der Software in
dem Ausmaß in dem es durch das Update oder Upgrade ersetzt wird. Durch das betreffende
Upgrade oder Update und den dazugehörigen Freischaltcode wird keine zweite Lizenz für die
Software gewährt, und Sie dürfen die Kopie des Upgrades oder Updates nicht zusätzlich zu der
Kopie der Software verwenden, die dadurch ersetzt wird und dessen Lizenz beendet wurde.
(h) Eigentumsrecht. Das Eigentumsrecht an der Software wird Ihnen nicht
übertragen. Alle Exemplare der Software und alle von Ihnen angefertigte Kopien verbleiben –
vorbehaltlich der Ihnen durch diesen Lizenzvertrag 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 Lizenzvertrags Ihr Eigentum ausser diese wurden mit einer Testsoftware
gemäß Abschnitt 4 dieser Vereinbarung erstellt. In diesem Fall wird Ihnen nur eine beschränkte
Lizenz zur Nutzung sämtlicher Ergebnisse, welche einen generierten Programmcode (inklusive
eines unbeschränkten Quellcodes) enthalten, wie Java, C++, C#, VB.NET oder XSLT und
verbundene Projektdateien und Build Scripts sowie generierte XML, XML Schematas,
© 2010 Altova GmbH
Lizenzinformationen 421Anhänge
Altova UModel 2010
Dokumentationen, UML Diagrammen und Datenbankstrukturen, für die 30 Tage dauernde
Testperiode eingeräumt.
(i) Reverse Engineering. Sofern dies nicht ausdrücklich nach geltendem Recht
der Europäischen Union gestattet ist, sind Sie nicht berechtigt, an der Software Reverse
Engineering durchzuführen, die Software zu dekompilieren, zu disassemblieren, oder auf
andere Weise zu versuchen, den Quellcode, zugrunde liegende Konzepte, Techniken für
Benutzerschnittstellen oder Algorithmen der Software direkt oder indirekt zu entschlüsseln.
Davon ausgenommen ist lediglich das ausdrücklich nach geltendem Recht der Europäischen
Union gestattete Maß an Dekompilierung, das erforderlich ist, um die Funktionsfähigkeit der
Software mit anderen Softwareprogrammen zu erzielen. Dies ist Ihnen jedoch erst dann
gestattet, wenn Sie zuerst bei Altova die dafür notwendigen Informationen angefordert haben
und Altova Ihnen diese nicht zur Verfügung gestellt hat. Altova ist berechtigt, für die
Bereitstellung solcher Informationen angemessene Bedingungen aufzustellen und eine
angemessene Entschädigung zu verlangen. Die von Altova zur Verfügung gestellten
Informationen bzw. alle von Ihnen im Sinne der hier festgelegten Bestimmungen rechtmäßig
erworbenen Informationen dürfen nur zu den hierin angeführten Zwecken verwendet und
keinesfalls an Dritte weitergegeben oder zur Entwicklung von Software genutzt werden, die der
Software, die Gegenstand dieses Lizenzvertrags ist, in wesentlichen Aspekten ähnlich ist.
Informationen im Sinne dieses Absatzes können von Benutzern aus der Europäischen Union
bei der Kundendienstabteilung von Altova angefordert werden.
(j) Sonstige Beschränkungen. Sie sind nicht berechtigt, die Software (zur Gänze
oder teilweise) zu verleihen, zu vermieten, per Leasing zur Verfügung zu stellen,
weiterzulizenzieren, weiterzugeben oder auf sonstige Weise Dritten zu überlassen, es sei denn,
dies ist durch die Bestimmungen in Abschnitt 3 oder an anderer Stelle in diesem Lizenzvertrag
ausdrücklich gestattet. Sofern dies nicht ausdrücklich in diesem Vertrag gestattet ist, dürfen Sie
die Software nicht kopieren. Alle Kopien, zu deren Anfertigung Sie berechtigt sind, müssen die
im Original enthaltenen urheber- und patentrechtlichen Angaben sowie alle anderen Angaben
hinsichtlich geistiger Eigentumsrechte unverändert enthalten. Die Software darf nicht verändert,
adaptiert oder übersetzt werden. Sie dürfen weder direkt noch indirekt ein Pfand- oder
Sicherungsrecht an der Software bestellen oder die Bestellung eines solchen zulassen. Es ist
Ihnen nicht gestattet, wissentlich eine Handlung vorzunehmen, durch die die Software öffentlich
zugänglich wird, oder die Software in einer Computerumgebung zu verwenden, die nicht in
diesem Lizenzvertrag angegeben ist. Sie haben die geltenden gesetzlichen Bestimmungen und
die Anweisungen von Altova in Bezug auf die Benutzung der Software einzuhalten. Sie sind
verpflichtet, Ihre Mitarbeiter und Vertreter, die Zugriff auf die Software haben, von den in diesem
Lizenzvertrag enthaltenen Beschränkungen in Kenntnis zu setzen und diese auf sie zu
überbinden. SIE TRAGEN DIE ALLEINIGE VERANTWORTUNG FÜR DIE EIGNUNG UND
ZWECKMÄSSIGKEIT DER SOFTWARE FÜR DEN BEABSICHTIGTEN
VERWENDUNGSZWECK UND WERDEN ALTOVA FÜR JEGLICHE ANSPRÜCHE UND
FORDERUNGEN DRITTER, DIE AUF DIE EIGNUNG UND ZWECKMÄSSIGKEIT DER VON
IHNEN VERWENDETEN SOFTWARE BEGRÜNDET SIND, SCHAD- UND KLAGLOS
HALTEN. DIE SOFTWARE IST KEINESFALLS FÜR DIE VERWENDUNG IN
KERNKRAFTANLAGEN, FLUGZEUGNAVIGATIONS-, KOMMUNIKATIONS- ODER
LUFTVERKEHRSKONTROLLSYSTEMEN KONZIPIERT, BEI DENEN DER AUSFALL DER
422 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
SOFTWARE ZU TODESFÄLLEN, PERSONENSCHÄDEN ODER SCHWEREN SACH- ODER
UMWELTSCHÄDEN FÜHREN KÖNNTE.
(k) ES WIRD KEINE GARANTIE ODER GEWÄHRLEISTUNG FÜR DIE
FEHLERFREIHEIT DER SOFTWARE ABGEGEBEN ODER GEWÄHRT UND VON ALTOVA
KEINERLEI HAFTUNG DIESBEZÜGLICH ÜBERNOMMEN. UNABHÄNGIG VON
IRGENDWELCHEN SUPPORTLEISTUNGEN NACH IRGENDEINEM TECHNISCHEN
STANDARD IST DIE SOFTWARE KEINESFALLS FÜR DIE VERWENDUNG IN ODER IM
ZUSAMMENHANG MIT KERNKRAFTANLAGEN, FLUGGERÄTENAVIGATION,
KOMMUNIKATIONSSYSTEMEN ODER LUFTVERKEHRSKONTROLLEINRICHTUNGEN,
MEDIZINISCHEN GERÄTEN ODER LEBENSERHALTUNGSSYSTEMEN, MEDIZINISCHEN
ODER DIE GESUNDHEITSVORSORGE BETREFFENDEN ANWENDUNGEN, ODER
SONSTIGEN ANWENDUNGEN KONZIPIERT, BEI DENEN FEHLER DER SOFTWARE ODER
FEHLER BEI DER DATENVERARBEITUNG ZU TODESFÄLLEN, PERSONENSCHÄDEN
ODER SCHWEREN SACH- ODER UMWELTSCHÄDEN FÜHREN KÖNNTEN. SIE
ERKLÄREN SICH DAMIT EINVERSTANDEN, DASS SIE DIE ALLEINIGE
VERANTWORTUNG FÜR DIE EIGNUNG UND ZWECKMÄSSIGKEIT DER SOFTWARE UND
ALLE MIT DER SOFTWARE ERSTELLTEN ODER VERARBEITETEN DATEN FÜR DEN
BEABSICHTIGTEN VERWENDUNGSZWECK TRAGEN UND SIE WERDEN ALTOVA UND
DEREN GESCHÄFTSFÜHRER SOWIE ANGESTELLTE HINSICHTLICH ALLER
ANSPRÜCHE, FORDERUNGEN UND KLAGEN DRITTER, DIE AUF DIE EIGNUNG UND
ZWECKMÄSSIGKEIT DER VON IHNEN VERWENDETEN SOFTWARE ODER DIE VON DER
SOFTWARE ERSTELLTEN DATEN GEGRÜNDET SIND, SCHAD- UND KLAGLOS HALTEN.
2. GEISTIGE EIGENTUMSRECHTE
Anerkennung der Rechte von Altova. Die Software und alle Kopien, deren
Anfertigung Ihnen von Altova gestattet ist, sind das geistige Eigentum von Altova und dessen
Lieferanten und stehen in deren Besitz. Struktur, Organisation und Code der Software stellen
wertvolle Betriebsgeheimnisse und vertrauliche Informationen von Altova und dessen
Lieferanten dar. Die Software ist durch gesetzliche Bestimmungen urheberrechtlich geschützt.
Diese gesetzlichen Bestimmungen beinhalten (ohne darauf beschränkt zu sein) das
Urheberrecht der Vereinigten Staaten, internationale Verträge und das in den Ländern, in denen
die Software genutzt wird, geltende Recht. Sie anerkennen, dass sich Altova das Eigentum an
allen Patenten, Urheberrechten, Branchengeheimnissen, Warenzeichen und sonstigen
geistigen Eigentumsrechten, die hinsichtlich der Software bestehen, vorbehält. Das
Eigentumsrecht von Altova erstreckt sich auch auf alle Bilder, Fotografien, Animationen,
Videos, Audioaufzeichnungen, Musikstücke, Texte und „Applets“, die Teil der Software sind,
und alle dazugehörigen Unterlagen in gedruckter Form. Sie dürfen keine Handlungen
vornehmen, die sich nachteilig auf die geistigen Eigentumsrechte von Altova an der Software
auswirken. Warenzeichen dürfen nur in Übereinstimmung mit den anerkannten Standards für
die Verwendung von Warenzeichen (einschließlich der namentlichen Nennung der
Warenzeicheninhaber) verwendet werden. Die Verwendung von Warenzeichen ist nur zur
Kennzeichnung von Druckmaterialien, die mit der Software hergestellt wurden, gestattet. Es
entstehen Ihnen daraus keinerlei Eigentumsrechte an dem betreffenden Warenzeichen.
XMLSpy, Authentic, StyleVision, MapForce, Markup Your Mind, Axad, Nanonull und Altova sind
© 2010 Altova GmbH
Lizenzinformationen 423Anhänge
Altova UModel 2010
(in mehreren Ländern eingetragene) Warenzeichen von Altova GmbH. Unicode und das Logo
von Unicode sind Warenzeichen von Unicode, Inc. Windows, Windows XP, Windows Vista, und
Windows 7 sind Warenzeichen von Microsoft. W3C, CSS, DOM, MathML, RDF, XHTML, XML
und XSL sind (in mehreren Ländern eingetragene) Warenzeichen des World Wide Web
Consortium (W3C). Marken des W3C sind von den Dachinstitutionen des Konsortiums (MIT,
INRIA und Keio) eingetragen und stehen in deren Eigentum. Sofern dies nicht ausdrücklich
hierin festgelegt ist, entstehen Ihnen aus diesem Lizenzvertrag keinerlei geistigen
Eigentumsrechte an der Software. Mitteilungen über geltend gemachte Verstöße gegen geistige
Eigentumsrechte sind an den Copyright Agent von Altova zu richten (nähere Angaben dazu
finden Sie auf der Website von Altova).
3. ÜBERTRAGUNGSBESCHRÄNKUNG
Ungeachtet der vorstehenden Bestimmungen dürfen Sie alle Ihre Rechte zur
Verwendung der Software an eine andere natürliche oder juristische Person unter der
Voraussetzung übertragen, dass: (a) Sie den vorliegenden Lizenzvertrag, die Software und
sonstige Soft- oder Hardware, die mit der Software, die Gegenstand dieses Lizenzvertrags ist,
geliefert, verpackt oder auf dieser vorinstalliert ist, einschließlich aller Kopien, Updates und
früherer Versionen sowie aller Exemplare von Fontsoftware, die in andere Formate konvertiert
wurde, an die betreffende Person übertragen; (b) Sie keine Kopien, einschließlich
Sicherungskopien und sonstiger, auf einem Computer gespeicherter Kopien, zurückbehalten;
(c) der Empfänger von Altova einen persönlichen Freischaltcode von Altova erhält; und (d) der
Empfänger die Bestimmungen dieses Lizenzvertrags sowie alle anderen Bestimmungen
akzeptiert, zu denen Sie die Softwarelizenz rechtmäßig erworben haben. Ungeachtet der
vorstehenden Ausführungen dürfen Sie keine Schulungs-, Vorab- oder Musterkopien der
Software an Dritte übertragen.
4. ZUSÄTZLICHE BEDINGUNGEN FÜR VORAB- UND TESTVERSIONEN
Wenn es sich bei dem von Ihnen mit dieser Lizenz erworbenen Produkt um eine
unverkäufliche Vorabversion oder um Beta-Software („Pre-Release-Software“) handelt, gelten
die in diesem Abschnitt enthaltenen Bedingungen. Diese gelten außerdem für alle Test-
und/oder Demoversionen von Altova-Software („Testsoftware“) und bleiben so lange gültig, bis
Sie eine Lizenz erwerben. Wenn Bestimmungen dieses Abschnitts im Widerspruch zu anderen,
in diesem Lizenzvertrag enthaltenen Bestimmungen stehen, dann gehen die Bedingungen
dieses Abschnitts hinsichtlich Pre-Release-Software und Testsoftware allen anderen
Bestimmungen dieses Lizenzvertrags vor, soweit dies für die Auflösung des Widerspruchs
erforderlich ist. Sie erkennen an, dass es sich bei der Pre-Release-Software um eine
Vorabversion handelt, die nicht das endgültige Produkt von Altova darstellt, und in der Fehler,
Funktionsstörungen oder andere Probleme auftreten können, die möglicherweise zu einem
System- oder Hardwareabsturz oder -fehler bzw. zu Datenverlust führen. DIE
PRE-RELEASE-SOFTWARE UND/ODER TESTSOFTWARE WIRD IHNEN DAHER OHNE
GEWÄHR FÜR DEREN VERWENDUNG ODER LEISTUNGSMERKMALE ZUR VERFÜGUNG
GESTELLT, UND ALTOVA ÜBERNIMMT DIESBEZÜGLICH KEINERLEI AUSDRÜCKLICHEN
ODER STILLSCHWEIGENDEN GEWÄHRLEISTUNGS- ODER
HAFTUNGSVERPFLICHTUNGEN. SOFERN UND SOWEIT FÜR PRE-RELEASE- UND/ODER
424 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
TESTSOFTWARE KEIN HAFTUNGSSAUSSCHLUSS, SONDERN NUR EINE
HAFTUNGSBESCHRÄNKUNG GESETZLICH ZULÄSSIG IST, BESCHRÄNKT SICH DIE
HAFTUNG VON ALTOVA UND DESSEN LIEFERANTEN AUF INSGESAMT FÜNFZIG
US-DOLLAR (50 USD). Wenn die Testversion mit einer Time-out-Funktion ausgestattet ist,
kann sie nach Ablauf des Evaluierungszeitraums nicht mehr verwendet werden. Mit dem Ablauf
dieses Zeitraums endet Ihre Lizenz automatisch, wenn Sie sie nicht verlängern. Ihre Lizenz zur
Nutzung sämtlicher mit der Testsoftware erstellten Ergebnisse, welche einen generierten
Progammcode (inklusive den unbeschränkten Quellcode) wie Java, C++, C#, VB.NET oder
XSLT und verbundene Projektdateien und Build Scripts sowie generierte XML, XML
Schematas, Dokumentationen, UML Diagramme und Datenbankstrukturen enthalten, erlischt
automatisch nach Ablauf der vorgesehenen Testperiode. Die Lizenz zum Gebrauch dieser
Ergebnisse lebt nach dem Kauf einer Lizenz für die Software, die Sie getestet und mit der Sie
das Ergebnis erstellt haben, wieder auf.
Der Zugriff auf Dateien, die mit der Testsoftware erstellt wurden, erfolgt auf Ihr alleiniges Risiko.
Sie bestätigen, dass Altova Ihnen weder zugesichert noch garantiert hat, die
Pre-Release-Software zu einem späteren Zeitpunkt anderen Personen anzukündigen oder zur
Verfügung zu stellen. Sie bestätigen ferner, dass Altova sich Ihnen gegenüber weder
ausdrücklich noch stillschweigend verpflichtet hat, die Pre-Release-Software öffentlich
anzukündigen oder einzuführen, und dass Altova kein Produkt anbieten muss, das der
Pre-Release-Software ähnlich oder mit ihr kompatibel ist. Sie bestätigen folglich, dass jegliche
Forschungs- oder Entwicklungsarbeit, die Sie in Bezug auf die Pre-Release-Software oder
damit verbundene Produkte ausführen, in Ihr alleiniges Risiko fällt. Wenn Altova Sie dazu
auffordert, werden Sie für die Dauer dieses Lizenzvertrags 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 Vereinbarung erhalten haben, unterliegt Ihre Verwendung der Software den darin
enthaltenen Bedingungen. Es ist Ihnen nicht gestattet, die Pre-Release-Software
unterzulizenzieren, per Leasing zur Verfügung zu stellen, zu verleihen, zu vermieten,
weiterzugeben oder auf sonstige Weise Dritten zu überlassen. Sie verpflichten sich, bei Erhalt
einer späteren unveröffentlichten Version der Pre-Release-Software bzw. bei Erhalt einer
kommerziellen Vollversion von Altova (entweder als Einzelprodukt 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 die betreffende spätere Version der
Pre-Release-Software Folge zu leisten.
5. EINGESCHRÄNKTE GARANTIE UND HAFTUNGSBESCHRÄNKUNG
(a) Eingeschränkte Garantie und Garantieansprüche der Kunden. Altova
garantiert der Person/Rechtspersönlichkeit, die ursprünglich die Lizenz für die Verwendung der
Software gemäß den Bestimmungen dieses Lizenzvertrags erworben hat, dass (i) die Software
über einen Zeitraum von neunzig (90) Tagen nach Erhalt im Wesentlichen in Übereinstimmung
mit der dazugehörigen Dokumentation funktioniert, und (ii) die von Altova zur Verfügung
gestellten Supportleistungen im Wesentlichen auf die in Abschnitt 6 dieses Vertrags
niedergelegte Weise erfolgen. In einigen Ländern sind Beschränkungen über die Dauer einer
stillschweigenden Garantie nicht zulässig, so dass die obigen Beschränkungen und
© 2010 Altova GmbH
Lizenzinformationen 425Anhänge
Altova UModel 2010
Ausschlüsse eventuell für Sie nicht zutreffen. Im größtmöglichen rechtlich zulässigen Maß sind
stillschweigende Garantien in Bezug auf die Software (sofern solche existieren) auf neunzig
(90) Tage beschränkt. Die gesamte Haftung von Altova und dessen Lieferanten, sowie Ihre
einzigen Garantieansprüche, sind nach dem Ermessen von Altova auf eine der beiden
folgenden Optionen beschränkt: (i) Erstattung des Kaufpreises (wenn zutreffend), oder (ii)
Reparatur oder Austausch der Software, die unter die eingeschränkte Garantie von Altova fällt
und die unter Vorlage einer Kopie des Kaufbelegs bei Altova reklamiert wird. Diese
eingeschränkte Garantie gilt nicht, wenn die Funktionalität der Software durch ein Versehen,
durch Missbrauch, falsche Anwendung, Trojaner, Viren oder einen sonstigen schädlichen
externen Code beeinträchtigt wurde. Die Garantie für jede Ersatzsoftware erstreckt sich auf die
Restdauer des ursprünglichen Garantiezeitraums oder auf dreißig (30) Tage, je nachdem,
welcher Zeitraum länger ist. Die eingeschränkte Garantie gilt nicht für Test- und/oder
Pre-Release-Software.
(b) Keine weiteren Garantien, Haftungsausschluss. MIT AUSNAHME DER
VORSTEHEND ANGEFÜHRTEN EINGESCHRÄNKTEN GARANTIE UND DEN
DIESBEZÜGLICHEN GARANTIEANSPRÜCHEN BESTEHEN SEITENS ALTOVA ODER
DESSEN LIEFERANTEN KEINERLEI WEITEREN GARANTIEVERPFLICHTUNGEN. ALTOVA
UND DESSEN LIEFERANTEN ÜBERNEHMEN KEINE GEWÄHR FÜR DIE ANWENDUNG
ODER DIE ERGEBNISSE AUS DER NUTZUNG DER SOFTWARE. MIT AUSNAHME DER
VORSTEHEND ANGEFÜHRTEN EINGESCHRÄNKTEN GARANTIE SOWIE IM HINBLICK
AUF ALLE ANDEREN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN ODER
ANSPRÜCHE, DIE NACH DER FÜR IHR LAND GELTENDEN RECHTSORDNUNG NICHT
AUSGESCHLOSSEN ODER EINGESCHRÄNKT WERDEN KÖNNEN, SCHLIESSEN ALTOVA
UND DESSEN LIEFERANTEN ALLE ANDEREN AUSDRÜCKLICHEN ODER
STILLSCHWEIGENDEN GEWÄHRLEISTUNGEN, BEDINGUNGEN, ZUSICHERUNGEN UND
ANSPRÜCHE AUS, DIE SICH AUS DEM GESETZ, DER RECHTSPRAXIS, EINEM
GEWOHNHEITSRECHT, EINEM HANDELSBRAUCH ODER AUS SONSTIGEN GRÜNDEN
ERGEBEN. ALTOVA UND DESSEN LIEFERANTEN SCHLIESSEN IM GRÖSSTMÖGLICHEN
RECHTLICH ZULÄSSIGEN UMFANG ALLE ANDEREN AUSDRÜCKLICHEN UND
STILLSCHWEIGENDEN GARANTIEN UND GEWÄHRLEISTUNGEN AUS. DIES
BEINHALTET UNTER ANDEREM GARANTIEN IM HINBLICK AUF MARKTGÄNGIGKEIT,
EIGNUNG FÜR EINEN BESTIMMTEN ZWECK, ZUFRIEDENSTELLENDE QUALITÄT,
INFORMATIONSGEHALT ODER –RICHTIGKEIT, UNGESTÖRTE NUTZUNG,
EIGENTUMSRECHT UND NICHTVERLETZUNG VON RECHTEN DRITTER UND DIE
ERBRINGUNG ODER NICHTERBRINGUNG VON SUPPORTLEISTUNGEN IN BEZUG AUF
DIE SOFTWARE. MIT DIESER EINGESCHRÄNKTEN GARANTIE WERDEN IHNEN
BESTIMMTE RECHTE EINGERÄUMT. UNTER UMSTÄNDEN BESITZEN SIE NOCH ANDERE
RECHTE, DIE JE NACH LAND/RECHTSORDNUNG UNTERSCHIEDLICH SEIN KÖNNEN.
(c) Haftungsbeschränkung. SOWEIT DIE ANWENDBAREN GESETZE DIES
ZULASSEN, HAFTEN ALTOVA ODER DESSEN LIEFERANTEN, AUCH WENN EINE IM
RAHMEN DER GARANTIE DURCHGEFÜHRTE ABHILFEMASSNAHME IHREN
WESENTLICHEN ZWECK NICHT ERFÜLLT, IN KEINEM FALL FÜR KONKRETE, ZUFÄLLIG
ENTSTANDENE, MITTELBARE, UNMITTELBARE ODER FOLGESCHÄDEN JEGLICHER
ART (INSBESONDERE SCHÄDEN AUS ENTGANGENEM GEWINN,
426 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
GESCHÄFTSUNTERBRECHUNGEN, VERLUST VON GESCHÄFTSINFORMATIONEN ODER
ANDEREN FINANZIELLEN VERLUSTEN), DIE DURCH DIE NUTZUNG ODER DIE
UNMÖGLICHKEIT DER NUTZUNG DER SOFTWARE ODER DIE NICHTERBRINGUNG VON
SUPPORTLEISTUNGEN ENTSTANDEN SIND, SELBST WENN ALTOVA AUF DIE
MÖGLICHKEIT EINES SOLCHEN SCHADENS HINGEWIESEN WURDE. IN JEDEM FALL IST
DIE GESAMTHAFTUNG VON ALTOVA GEMÄSS DIESEM LIZENZVERTRAG AUF DIE HÖHE
DES FÜR DAS SOFTWAREPRODUKT ENTRICHTETEN BETRAGES BESCHRÄNKT. Da es
in einigen Ländern und Rechtsordnungen nicht zulässig ist, die Haftung für Schäden
auszuschließen oder zu beschränken, gilt die obige Einschränkung unter Umständen nicht für
Sie. In solchen Ländern und Rechtsordnungen gilt die Beschränkung der Haftung durch Altova
im größtmöglichen rechtlich zulässigen Umfang, und der Ausschluss bzw. die Beschränkung
der in diesem Lizenzvertrag beinhalteten Garantien und Haftungen hat keine Auswirkung auf
die Konsumentenschutzrechte von Personen, die Waren auf andere Weise als im Zuge ihrer
geschäftlichen Tätigkeit erwerben. Der vorstehende Haftungssauschluss/die vorstehende
Haftungsbeschränkung sind wesentliche Bestandteile des zwischen Ihnen und Altova
abgeschlossenen Lizenzvertrags.
(d) Ansprüche in Zusammenhang mit Urheberrechtsverletzungen. Altova wird
Sie gegenüber allen Forderungen, Prozessen oder Verfahren schad- und klaglos halten bzw.
alle Ansprüche, Prozesse oder Verfahren beilegen, die Dritte mit dem Argument gegen Sie
erheben, dass der Inhalt der Software gegen ein Urheberrecht verstößt oder ein geistiges oder
sonstiges Eigentumsrecht verletzt, das durch das Recht der Vereinigten Staaten oder der
Europäischen Union geschützt ist (insgesamt als „Ansprüche“ bezeichnet). Dies erfolgt – soweit
nicht ausdrücklich etwas Anderes festgelegt ist – jedoch nur insoweit, als der betreffende
Anspruch sich direkt aus der Verwendung der Software ergibt und nach Maßgabe der in
Abschnitt 5 dieses Vertrags festgelegten Beschränkungen. Altova ist von jedem Anspruch
innerhalb von zehn (10) Geschäftstagen, nachdem Sie erstmals davon benachrichtigt wurden,
in Kenntnis zu setzen. Außerdem haben Sie mit Altova in angemessenem Umfang bei der
Abwehr solcher Ansprüche zu kooperieren und Altova dabei zu unterstützen, ohne dass Sie
dafür Kosten geltend machen können. Das Recht auf Entscheidungen in Bezug auf solche
Ansprüche liegt allein bei Altova (dies beinhaltet auch, ohne darauf beschränkt zu sein, die
Auswahl der Rechtsberater und das Recht, für Sie einen Vergleich zu den von Altova für
zweckmäßig erachteten Bedingungen einzugehen). Sie können auf eigene Kosten einen
Rechtsberater hinzuziehen und an den Verfahrens- oder Vergleichsverhandlungen teilnehmen.
Altova kommt bis zu einer Höhe von insgesamt maximal dem Kaufpreis der Software für die
Schäden, Kosten und Anwaltsgebühren auf, zu deren Bezahlung Sie in Zusammenhang mit
solchen Ansprüchen verpflichtet werden (oder die Sie aufgrund eines Vergleichs zu entrichten
haben), soweit diese nicht von einer Versicherung oder dritten Partei übernommen werden. Ist
oder wird die Software Gegenstand von aufgrund einer Urheberrechtsverletzung vorgebrachten
Ansprüchen, oder wird ihre Verwendung untersagt, oder ist es nach Ansicht des Rechtsberaters
von Altova wahrscheinlich, dass ein solcher Umstand eintritt, so wird Altova versuchen, eine
Beilegung herbeizuführen, indem alle wirtschaftlich vertretbaren Anstrengungen unternommen
werden, um die Software zu modifizieren oder eine Lizenz für die weitere Verwendung der
Software zu erwerben. Wenn es nach Ansicht des Rechtsberaters von Altova nicht möglich ist,
den bevorstehenden oder bereits vorgebrachten Anspruch bzw. die Verfügung, mit der die
Verwendung der Software untersagt wurde, durch angemessene Abänderung oder den Erwerb
© 2010 Altova GmbH
Lizenzinformationen 427Anhänge
Altova UModel 2010
einer Lizenz beizulegen, so kann Altova diesen Lizenzvertrag ohne negative Konsequenzen für
Altova beenden und Ihnen anteilig alle bereits an Altova entrichteten Gebühren zurückerstatten.
MIT AUSNAHME DER VORSTEHEND ANGEFÜHRTEN BESTIMMUNGEN OBLIEGEN
ALTOVA KEINERLEI HAFTUNGSVERPFLICHTUNGEN FÜR ANSPRÜCHE IN
ZUSAMMENHANG MIT URHEBERRECHTSVERLETZUNGEN. Diese Haftungsverpflichtung
gilt nicht für Urheberrechtsverletzungen, die ausschließlich auf vom Kunden eingebrachte
Elemente zurückzuführen sind.
6. SUPPORT UND WARTUNG
Zusätzlich zu der Version des Softwareprodukts, für das Sie eine Lizenz erhalten
haben, bietet Altova eine Reihe von optionalen „Support- & Wartungspaketen“ („Software &
Maintenance Package“, „SMP“) an, die Sie zusätzlich zu Ihrer Lizenz für die Software erwerben
können. Der für das jeweilige SMP geltende Supportzeitraum (wie nachfolgend definiert) wird
beim Kauf des SMP festgelegt. Die Support- und Wartungsservices und die Upgrades, die
Ihnen zur Verfügung stehen, hängen davon ab, ob Sie ein SMP erwerben bzw. für welche
Version des SMP Sie sich entscheiden.
(a) Wenn Sie kein SMP erwerben, erhalten Sie beim Kauf lediglich die Software,
danach jedoch keinerlei Wartungsreleases oder Updates. Obwohl die Möglichkeit besteht, dass
Altova Ihnen in Einzelfällen Wartungsreleases als kostenlose Zusatzleistung zur Verfügung
stellt, sind in diesen Releases keine neuen Produktfeatures, die über das beim Kauf der
Software bestehende Maß hinausgehen, beinhaltet. In jedem Fall erhalten Sie dreißig (30) Tage
lang ab Kauf der Software (der „Supportzeitraum” im Sinne dieses Absatzes (a)) kostenlosen
technischen Support von Altova. Außerdem kann Altova in Einzelfällen auch während des
dreißig (30) Tage dauernden Evaluierungszeitraums technischen Support als kostenlose
Zusatzleistung zur Verfügung stellen. Technischen Support erhalten Sie ausschließlich über ein
webbasiertes Supportformular, wobei es keine garantierte Reaktionszeit gibt.
(b) Mit dem Erwerb eines SMP haben Sie während des dafür geltenden
Supportzeitraums Anspruch auf die von Ihnen erworbene Produktversion sowie auf alle
Wartungsreleases und Updates für diese Produktversion, die während des für Sie geltenden
Supportzeitraumsfreigegeben werden. Während des Supportzeitraums Ihres SMP erhalten Sie
auch Upgrades auf die entsprechende Produktversion der Software, mit der auf eine höhere
Version der Software, für die Sie die Lizenz erworben haben, gewechselt wird und die während
Ihres Supportzeitraums freigegeben werden. Die einzelnen Upgradeeditionen, auf die Sie
innerhalb Ihres Supportzeitraums Anspruch haben, sind in dem von Ihnen erworbenen SMP im
Detail angeführt. Software, die als gesondertes Produkt eingeführt wird, ist nicht im SMP
enthalten. Wartungsreleases, Updates und Upgrades können neue Features enthalten, dies
muss aber nicht der Fall sein. Darüber hinaus erhalten Sie während des Supportzeitraums
bevorzugten technischen Support von Altova, und zwar ausschließlich über ein webbasiertes
Supportformular. Altova wird alle wirtschaftlich vertretbaren Anstrengungen unternehmen, um
alle Anfragen per E-Mail innerhalb von achtundvierzig (48) Stunden während der
Geschäftszeiten (Montag bis Freitag, 8.00 bis 22.00 Uhr UTC, ausgenommen Feiertage in
Österreich und den USA) zu beantworten. Außerdem wird Altova sich in angemessenem
Umfang darum bemühen, Workarounds für Fehler, die bei der Software aufgetreten sind, zur
Verfügung zu stellen.
428 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
Während des Supportzeitraums können Sie Altova Fehler oder Defekte in der Software
melden. Wenn nach Altovas Einschätzung ein reproduzierbarer schwerwiegender Fehler
vorliegt, der die Verwendung und Funktionalität der Software erheblich beeinträchtigt, wird
Altova wirtschaftlich vertretbaren Anstrengungen unternehmen um Korrekturen oder
provisorische Lösungen anzubieten, die in zukünftigen Updates oder Wartungsreleases
enthalten sind. Diese Updates oder Wartungsreleases werden von Altova von Zeit zu Zeit zur
Verfügung gestellt.
Es steht im Ermessen von Altova, einen schriftlichen Nachweis über von Ihnen festgestellte
Fehler oder Funktionsstörungen zu verlangen oder Beispieldateien anzufordern, aus denen das
aufgetretene Softwareproblem hervorgeht. In einem solchen Fall müssen Sie die angeforderten
Nachweise oder Dateien, aus denen ausreichend detailliert hervorgeht, in welchen Aspekten
Fehler bei der Software auftreten, so schnell wie möglich per E-Mail, Fax oder Expresspost mit
Zustellung am nächsten Tag an Altova übermitteln. Bei der Diagnose oder Analyse von Fehlern
haben Sie in zumutbarem Rahmen mit Altova zu kooperieren. Fehlerbehebungen können in
Wartungsreleases, Updates oder neuen Hauptversionen der Software enthalten sein. Altova ist
nicht verpflichtet, unwesentliche Fehler, d.h. Fehler, die die Benutzung der Software nicht
wesentlich beeinträchtigen, zu beheben. Unabhängig davon, ob Sie das Support- und
Wartungspaket erworben haben, wird technischer Support ausschließlich für Fragen oder
Probleme angeboten, die sich unmittelbar aus oder in Zusammenhang mit der Software
ergeben. Sie erhalten von Altova unter keinen Umständen Beratung, Unterstützung oder
Hilfestellung, die allgemeiner Natur ist und nicht in unmittelbarem Zusammenhang mit der
Software steht.
Bei der Aktualisierung der Software kann es unter Umständen vorkommen, dass vor
der Installation auch Software aktualisiert werden muss, die nicht unter diesen Lizenzvertrag
fällt. Für Updates von Betriebssystem- und Anwendungssoftware, die nicht ausdrücklich
Gegenstand dieses Lizenzvertrags ist, sind ausschließlich Sie verantwortlich. Solche Updates
sind nicht im Umfang dieser Lizenz enthalten und werden nicht von Altova zur Verfügung
gestellt. Die Erfüllung der in diesem Abschnitt 6 festgelegten Verpflichtungen durch Altova
versteht sich unter der Bedingung, dass Sie die Software ordnungsgemäß verwenden und
diesen Lizenzvertrag ausnahmslos jederzeit einhalten. Altova ist nicht verpflichtet, technischen
Support zu leisten, wenn nach Ansicht von Altova die Fehlfunktion der Software auf einen der
folgenden Gründe zurückzuführen ist: (i) Fehler, die durch die Verlegung der Software auf einen
anderen Rechner oder Speicherort hervorgerufen werden; (ii) Änderungen, Modifikationen oder
Versuche, die Software abzuwandeln, die von Altova nicht schriftlich genehmigt wurden; (iii)
äußere Einflüsse auf die Software, wie z.B. Naturkatastrophen, Stromausfälle,
Stromschwankungen oder Computerausfälle; (iv) Ihr Versäumnis die Software auf dem von
Altova festgelegten Release Level zu halten; oder (v) Nutzung der Software ohne vorherige
Genehmigung durch Altova zusammen mit einer anderen Software. Sie alleine sind dafür
verantwortlich: (i) allen Betriebs- und Fehlerbehebungsanleitungen von Altova Folge zu leisten,
Altova unverzüglich von Fehlern oder Defekten an der Software zu informieren und Altova eine
genaue Beschreibung dieser Fehler und/oder Defekte zu liefern; (ii) für den Schutz Ihrer
vertraulichen Informationen zu sorgen; (iii) Datensicherungssysteme und -abläufe für die
Wiederherstellung verlorener oder geänderter Dateien, Daten oder Programme einzurichten
und anzuwenden.
© 2010 Altova GmbH
Lizenzinformationen 429Anhänge
Altova UModel 2010
7. AKTIVIERUNG DER SOFTWARE, UPDATES UND LIZENZÜBERWACHUNG
(a) Lizenzüberwachung. Altova verfügt über ein integriertes
Lizenzüberwachungsmodul, das Ihnen hilft, unbeabsichtigte Verletzungen dieses Lizenzvertrags
zu vermeiden. Dabei kann Altova zur Lizenzüberwachung von verschiedenen installierten
Versionen der Software Ihr internes Netzwerk verwenden.
(b) Aktivierung der Software. Die Software von Altova kann Ihr internes
Netzwerk und Ihre Internetverbindung verwenden, um Angaben über Ihre Lizenz im Zuge
der Installation, Registrierung, Benutzung oder Aktualisierung an einen
Altova-Lizenzserver zu übertragen und diese zu verifizieren, um auf diese Weise eine
nicht lizenzierte oder illegale Verwendung der Software zu verhindern und den
Kundenservice von Altova weiter zu verbessern. Die Aktivierung erfolgt über einen
Austausch von lizenzbezogenen Daten zwischen Ihrem Computer und dem
Altova-Lizenzserver. Sie stimmen dieser Vorgangsweise von Altova zu und verpflichten
sich, allen diesbezüglichen Vorgaben Folge zu leisten. Sie erklären sich damit
einverstanden, dass die Verwendung von Freischaltcodes, welche nicht von Altova
erstellt werden oder wurden und nicht rechtmäßig von Altova oder einem dazu
berechtigten Wiederverkäufer erworben wurden, zum Zweck der Aktivierung oder
Nutzung der Software die gewerblichen Schutzrechte von Altova sowie die
Bestimmungen dieses Lizenzvertrages verletzt. Sie erklären sich weiters damit
einverstanden, dass Versuche mit dem Zweck der Umgehung oder Deaktivierung der
urheberrechtlichen Schutzmaßnahmen oder Lizenzmanagementsystemen von Altova die
gewerblichen Schutzrechte von Altova sowie die Bestimmungen dieses Lizenzvertrages
verletzen. Altova behält sich ausdrücklich das Recht vor, alle rechtlich verfügbaren
sowie angemessenen Mittel zu ergreifen, um derartige Praktiken zu verhindern und
entgangenen Gewinn, Schäden und Kosten zurückerstattet zu bekommen.
(c) LiveUpdate. Altova stellt Ihnen ein neues LiveUpdate
Benachrichtigungsservice zur Verfügung, welches kostenlos ist. Altova kann Ihr internes
Netzwerk und Ihre Internetverbindung verwenden, um Angaben über Ihre Lizenz an einen
LiveUpdate-Server von Altova zu übertragen, um Ihre Lizenz in gewissen Zeitabständen zu
verifizieren und festzustellen, ob ein Update für Sie verfügbar ist.
(d) Verwendung von Daten. Der gesamte Wortlaut der
Datenschutzbestimmungen von Altova kann unter http://www.altova.com/privacy eingesehen
werden. Die Datenschutzbestimmungen sind durch Bezugnahme Teil dieses Lizenzvertrags.
Durch Ihre Zustimmung zu den Bestimmungen dieses Lizenzvertrags bzw. durch Benutzung
der Software erklären Sie sich damit einverstanden, dass Altova für die in diesem Lizenzvertrag
und/oder in den Datenschutzbestimmungen (in der jeweils geltenden Fassung) genannten
Zwecke Daten erhebt, verarbeitet und weitergibt. Benutzer in Europa haben Kenntnis davon
und erklären sich damit einverstanden, dass Informationen zu ihrer Person in den Vereinigten
Staaten zu den in diesem Vertrag angeführten Zwecken verwendet werden. Altova behält sich
das Recht vor, diese Bestimmung des Lizenzvertrags und/oder der Datenschutzbestimmungen
jederzeit zu ändern. Wir legen Ihnen nahe, die auf der Website von Altova veröffentlichten
Datenschutzbestimmungen von Zeit zu Zeit erneut durchzulesen.
430 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
8. DAUER UND BEENDIGUNG
Dieser Lizenzvertrag wird folgendermaßen beendet: (a) indem Sie Altova eine
schriftliche Benachrichtigung von der Vertragsbeendigung übermitteln; (b) durch Altova in Form
einer diesbezüglichen schriftlichen Benachrichtigung, wenn Sie gegen diesen Lizenzvertrag
verstoßen und diesen Verstoß nicht innerhalb von 10 (zehn) Tagen, nachdem Altova Ihnen dies
mitgeteilt hat, berichtigen; oder (c) auf Verlangen eines autorisierten Vertriebshändlers von
Altova, wenn Sie eine Lizenzzahlung nicht entrichten oder sonstige Zahlungsverpflichtungen
nicht einhalten. Der Lizenzvertrag einer früheren Version der Software, für die Sie ein Upgrade
oder ein Update durchgeführt haben, wird mit Ihrer Zustimmung zu dem Lizenzvertrag, der für
das Upgrade oder Update gilt, automatisch beendet. Bei Beendigung des Lizenzvertrags dürfen
Sie die gesamte Software, die Gegenstand der Lizenz ist, nicht mehr verwenden, müssen alle
Kopien, die in Ihrem Besitz oder Einflussbereich stehen, vernichten, und müssen in
zumutbarem Rahmen alle von Altova geforderten Maßnahmen ergreifen, um sicherzustellen,
dass keine Kopien der Software in Ihrem Besitz oder Einflussbereich verbleiben. Die in den
Abschnitten 1(h), 1(i), 1(k), 2, 5(b), 5(c), 5(d), 7(d), 9, 10 und 11 niedergelegten Bestimmungen
bleiben auch nach Beendigung dieses Lizenzvertrags weiterhin aufrecht.
9. EINGESCHRÄNKTE RECHTE UND EXPORTBESCHRÄNKUNGEN
Die Entwicklung der Software wurde ausschließlich privat finanziert. Bei der Software
handelt es sich um kommerzielle Computersoftware, die mit eingeschränkten Rechten
ausgestattet ist. Die Verwendung, Vervielfältigung oder Weitergabe der Software durch die
US-Regierung, eine Behörde oder einen Kooperationspartner der US-Regierung unterliegt den
Beschränkungen im Rahmen dieses Vertrags sowie den Beschränkungen nach FAR 12.211
und 12.212 (48 C.F.R. §12.211 und 12.212) bzw. DFARS 227.7202 (48 C.F.R. §227-7202).
Dabei wird eine Lizenz für kommerzielle Computersoftware und kommerzielle
Computerdokumentation an die US-Regierung als Endnutzer ausschließlich in Form einer
Lizenz für kommerziell genutzte Güter erteilt, weshalb es sich bei den damit verbundenen
Rechten um dieselben Rechte handelt, die allen anderen Endnutzern im Rahmen dieses
Lizenzvertrags gewährt werden. Beim Hersteller handelt es sich um Altova GmbH, Rudolfsplatz,
13a/9, A-1010 Wien, Österreich/EU. Die Software und/oder Dokumentation darf ausschließlich
unter Einhaltung aller anwendbaren Exportbestimmungen der Vereinigten Staaten von Amerika
sowie des Landes, in dem Sie die Software erhalten haben, verwendet, exportiert oder
wiedereingeführt werden. Insbesondere darf die Software und/oder Dokumentation nicht (i) in
ein Land exportiert oder wiedereingeführt werden, über das die Vereinigten Staaten ein
Embargo verhängt haben, oder einem Staatsangehörigen oder Bewohner eines solchen
Landes überlassen werden; oder (ii) einer Person überlassen werden, die auf der Liste der
Specially Designated Nationals des U.S. Treasury Department oder dem Table of Denial Orders
des U.S. Department of Commerce verzeichnet sind. Indem Sie die Software benutzen,
erklären Sie, dass Sie weder in einem dieser Länder ansässig sind noch seiner Kontrolle
unterliegen, noch ein Staatsangehöriger oder Bewohner eines dieser Länder sind, noch auf
einer der vorstehend erwähnten Listen genannt werden.
10. SOFTWARE DRITTER
Die dieser Lizenz unterliegende Software kann Software Dritter enthalten, für die
© 2010 Altova GmbH
Lizenzinformationen 431Anhänge
Altova UModel 2010
ergänzende Vermerke und/oder Nutzungsbedingungen gelten. Diese Vermerke und
ergänzenden Nutzungsbedingungen für die Software Dritter können über unsere Website unter
http://www.altova.com/legal_3rdparty.html eingesehen werden und sind durch Bezugnahme Teil
dieses Lizenzvertrags. Indem Sie Ihre Zustimmung zu den Bedingungen dieses Vertrags
erteilen, stimmen Sie auch automatisch allen ergänzenden Bestimmungen, die möglicherweise
darin enthalten sind, zu.
11. ALLGEMEINE BESTIMMUNGEN
Wenn Sie sich in der Europäischen Union befinden und die Software in der
Europäischen Union und nicht in den Vereinigten Staaten verwenden, unterliegt dieser
Lizenzvertrag dem Recht der Republik Österreich (unter Ausschluss von dessen
Verweisungsnormen und der UN-Kaufrechtskonvention). Sie erklären sich ausdrücklich damit
einverstanden, dass alle Streitigkeiten oder Konflikte mit Altova, die in Zusammenhang mit Ihrer
Verwendung der Software stehen, in die alleinige Zuständigkeit des Handelsgerichts Wien
fallen. Sie erklären sich weiters ausdrücklich damit einverstanden, dass Sie bezüglich solcher
Streitigkeiten oder Konflikte der persönlichen Zuständigkeit des Handelsgerichts Wien
unterstellt sind.
Wenn Sie sich in den Vereinigten Staaten befinden und die Software in den Vereinigten
Staaten verwenden, unterliegt dieser Lizenzvertrag dem Recht des Commonwealth of
Massachusetts, USA (unter Ausschluss von dessen Verweisungsnormen und der
UN-Kaufrechtskonvention). Sie erklären sich ausdrücklich damit einverstanden, dass alle
Streitigkeiten oder Konflikte mit Altova, die in Zusammenhang mit Ihrer Verwendung der
Software stehen, in die alleinige Zuständigkeit der einzel- und bundesstaatlichen Gerichte im
Bundesstaat Massachusetts fallen. Sie erklären sich weiters ausdrücklich damit einverstanden,
dass Sie bezüglich solcher Streitigkeiten oder Konflikte der persönlichen Zuständigkeit der
einzel- und bundesstaatlichen Gerichte im Bundesstaat Massachusetts unterstellt sind.
Wenn Sie sich nicht in der Europäischen Union oder den Vereinigten Staaten befinden
und die Software nicht in den Vereinigten Staaten verwenden, unterliegt dieser Lizenzvertrag
dem Recht der Republik Österreich (unter Ausschluss von dessen Verweisungsnormen und der
UN-Kaufrechtskonvention). Sie erklären sich ausdrücklich damit einverstanden, dass alle
Streitigkeiten oder Konflikte mit Altova, die in Zusammenhang mit Ihrer Verwendung der
Software stehen, in die alleinige Zuständigkeit des Handelsgerichts Wien fallen. Sie erklären
sich weiters ausdrücklich damit einverstanden, dass Sie bezüglich solcher Streitigkeiten oder
Konflikte der persönlichen Zuständigkeit des Handelsgerichts Wien unterstellt sind. Die
Anwendung von Verweisungsnormen einer Rechtsordnung sowie des UN-Abkommens zum
internationalen Warenkauf (CISG) auf diesen Lizenzvertrag wird ausdrücklich ausgeschlossen.
Dieser Lizenzvertrag enthält die gesamte Vereinbarung zwischen den Parteien in Bezug
auf den Vertragsgegenstand und tritt an die Stelle aller diesbezüglichen früheren mündlichen
oder schriftlichen Vereinbarungen zwischen den Parteien. Benachrichtigungen oder sonstige
Mitteilungen im Rahmen dieses Lizenzvertrags müssen schriftlich erfolgen und gelten als
ordnungsgemäß übermittelt, wenn sie per Einschreiben mit Rückschein oder per Kurierdienst
mit Zustellung am nächsten Tag an die auf der Website von Altova angegebene Adresse (wenn
Altova der Empfänger ist) bzw. an die in den Aufzeichnungen von Altova für Sie eingetragene
Adresse (wenn Sie der Empfänger sind) oder aber an eine andere, von den Vertragspartnern
festgelegte und auf die vorstehend beschriebene Weise bekannt gegebene Adresse geschickt
432 Anhänge Lizenzinformationen
© 2010 Altova GmbHAltova UModel 2010
werden. Dieser Lizenzvertrag ist für die Vertragspartner verbindlich und geht auf ihre Erben,
persönlichen und rechtlichen Vertreter, verbundenen Unternehmen, Rechtsnachfolger und
zulässigen Abtretungsempfänger über. Die Nichtdurchsetzung oder Nichtausübung von
Rechten oder Rechtsmitteln unter diesem Lizenzvertrag durch die Vertragspartner stellt keinen
Verzicht auf ein solches Recht oder Rechtsmittel dar und beeinträchtigt in keiner Weise das
Recht des betreffenden Vertragspartners, ein solches Recht oder Rechtsmittel sowie alle
anderen Rechte oder Rechtsmittel aus diesem Lizenzvertrag später durchzusetzen bzw.
auszuüben. Eine Änderung dieses Lizenzvertrags ist nur Form einer schriftlich niedergelegten
Vereinbarung möglich, die von beiden Vertragspartnern unterzeichnet wird. Wenn eine
Zuwiderhandlung gegen die Bestimmungen dieses Lizenzvertrags durch einen der
Vertragspartner erfolgt ist oder droht, so kann der jeweils andere Vertragspartner alle ihm
zustehenden Rechte und Rechtsmittel geltend machen. Jeder Vertragspartner ist
ordnungsgemäß befugt und ermächtigt, in diesen Lizenzvertrag einzutreten und die daraus
erwachsenden Verpflichtungen zu erfüllen. Sollte eine Bestimmung dieses Lizenzvertrags für
unwirksam, rechtswidrig oder undurchführbar erklärt werden, so wird dadurch die Wirksamkeit
der übrigen Bestimmungen nicht berührt, und dieser Lizenzvertrag bleibt im größtmöglichen
rechtlich zulässigen Umfang wirksam und gültig. Die Vertragspartner haben die vorstehenden
Vertragsbedingungen zur Kenntnis genommen und erklären sich ausdrücklich damit
einverstanden.
Letzte Aktualisierung: 2010-04-26
© 2010 Altova GmbH
Index 433
Index
11.4,
Java, 61
55.0,
Java, 61
AAbgeleitete,
Klasse, 34
Klassen einfügen, 98
Abhängigkeit,
Beziehungen anzeigen, 89, 168
inkludieren, 18
Verwendung, 45
Absolute,
und relative Links, 170
Abstrakte,
Klasse, 27
Akteur,
benutzerdefiniert, 18
Aktiviere Versionskontrolle, 319
Aktivierungsfeld,
Ausführungsspezifikation, 221
Aktivität,
Diagramm zu Transition hinzufügen, 193
Diagrammelemente, 183
Verzweigung / Merge erstellen, 181
zum Zustand hinzufügen, 193
Aktivitätsdiagramm, 178
Elemente einfügen, 179
Symbole, 341
Aktualisieren,
Projektdatei, 134
Aktualisierung,
Statusaktualisierungen im Hintergrund, 310
Aktuellste Version holen, 320
Alle,
erweitern/reduzieren, 247
Anbieter,
Versionskontrolle, 296
Anbieter wechseln,
Versionskontrolle, 338
Anhänge, 412
Anleitung,
definierte Symbole, 123
Anmerkung,
Hyperlink von, 101
Annotation,
Dokumentation, 86
XML-Schema, 279
Anordnen,
Elemente, 93
Anpassen, 380
Befehle der Symbolleiste/des Menüs, 380
Kontextmenü, 384
Menü, 384
Ansicht, 378
zu mehreren Instanzen eines Elements, 247
Antwort,
Nachricht automatisch generieren, 227
Anwendungsfall,
hinzufügen, 18
Anzeigen,
alle Beziehungen - Hierarchie (Register), 83
Eigenschaft als Assoziation, 89
Eigenschaft als Assziation, 157
Eigenschaftswerte, 279
grafischen Ansicht, 83
Modellbeziehungen, 89, 168
oder am Raster ausrichten, 89
Textlabels, 89, 168
Applikation,
externe - Argumente, 381
Arbeitsablauf,
Projekt, 116
Arbeitsverzeichnis,
Versionskontrolle, 317
Argumente,
externe Tools, 381
Artefakt,
Manifestation, 50
zu Node hinzufügen, 50
Index
© 2010 Altova GmbH
434
Assoziation,
aggregrieren/zusammensetzen, 27
automatische Anzeige, 162
beim Code Engineering anzeigen, 61
Beziehungen anzeigen, 89, 168
Eigenschaft als Ass. anzeigen, 89
Klasse memberEnd, 162
mit Drag-and-Drop erstellen, 165
Objektverknüpfungen, 39
Qualifier, 162
Rolle, 162
Tpy definieren, 162
typisierte Eigenschaft anzeigen, 157
Use Case, 18
Zeilendicke, 89
zwischen Klassen, 27
Attribut,
Autokomplettierungsfenster, 386
Eigenschaftswerte ein-/ausblenden, 269
ein-/ausblenden, 247
in Modelll-Strukur auswählen, 78
Stereotyp, 269
Attribut auswählen,
in Modell-Struktur, 78
Attribute,
coloring, 252
Auflisten,
nicht verwendete Elemente, 69
Aufruf,
Nachricht, 227
Aufrufoperation,
einfügen, 179
Aufrufverhalten,
einfügen, 179
Ausblenden,
Eigenschaftswerte - Attribute, 269
einblenden - Slot, 247
Textlabels, 89, 168
Auschecken, 323
Auschecken rückgängig, 326
Ausführungsspezifikation,
Lebenslinie, 221
Ausgabe,
XMI-Datei, 292
Ausgliedern,
aus Versionskontrolle, 329
Auslösendes Ereignis,
Zeitverlaufsdiagramm, 242
Ausnahme,
Ausnahmeereignis hinzufügen, 247
Ausnahmeereignis,
hinzufügen, 247
Java-Operation, 123
Ausrichten,
am Raster - Raster anzeigen, 89
Elemente, 93
Außer Kraft setzen,
SPL-Standardvorlagen, 134
Austrittspunkt,
zu Unterautomat hinzufügen, 198
Autokomplettierung,
Einzelmodus / Mehrfachmodus, 93
Fenster - Typen, 93
Fenster zum Bearbeiten von Klassen, 386
Funktion, 27
Autokomplettierung auf Wunsch,
Strg+Leertaste, 93
Automatisch,
Assoziationen anzeigen, 162
Automatisch generieren,
Antwortnachricht, 227
Automatischer,
Hyperlink, 101
BBall and socket,
Interface notation, 247
Bank,
Beispieldateien, 106
Basis,
Klasse, 34
Basisklasse,
abgeleitete einfügen, 98
überschreiben, 247
Batch,
Batchverarbeitung, 114
new / load / save, 114
Verarbeitung, 110
vollständiger Batch-Modus, 114
Bearbeiten, 364
Bearbeitungen rückgängig machen, 326
Befehl,
aus Menü löschen, 384
© 2010 Altova GmbH
Index 435
Befehl,
Kontextmenü, 384
Menü zurücksetzen, 384
Zeile - new / load / save, 114
Zeilenverarbeitung, 114
Befehle,
zur Symbolleiste/zum Menü hinzufügen, 380
Befehlszeile,
Verarbeitung, 110
Beispiele,
Beispieldateien, 106
Ordner Tutorial, 12
Benutzer,
examples Ordner für mehrere Benutzer, 12
Benutzerdefinierte,
SPL-Vorlagen, 134
Stereotypstile, 275
Benutzerdefinierter,
Akteur, 18
Benutzeroberfläche, 68
Bereich,
einzelne/mehrere erweitern, 247
Beschleunigen,
Statusaktualisierungen im Hintergrund beschleunigen, 296
Bezeichnung,
IDs und UUIDs, 292
Beziehung,
alle anzeigen - Hierarchie (Register), 83
Modellbeziehungen anzeigen, 89, 168
Beziehungen,
Element, 162
Verwendung von Ziehpunkten, 165
Binärdateien,
C# und Java importieren, 128
Unterstützung von "obfuscated" Binärdateien, 128
Bitmap,
Elemente speichern, 364
Borland,
bsdj-Projektdatei, 367
Breite,
Linienbreite, 89
bsdj,
Borland-Projekt, 367
CC#,
Binärdatei importieren, 128
Code, 396
Code in Modell - Entsprechungen, 143
Importeinstellungen, 123
C++,
Code, 396
Call-Nachricht,
gehe zu Operation, 227
Cascading,
Styles, 80
Class,
syntax coloring, 252
Classifier,
einschränken, 153
neu, 137
umbenennen, 137
Code,
generieren - Mindestvoraussetzungen, 140
Java-Code und Klassendateinamen, 139
mehrere Sequenzdiagramm anhand von Code generieren,235
Refactoring, 139
Round Trip Engineering, 54
Sequenzdiagramm generieren, 232
SPL, 397
Standard, 386
Synchronisierung, 134
Voraussetzungen, 54
Zielverzeichnis, 54
Code - C#,
in UModel Elemente, 143
Code - VB.NET,
to UModel elements, 145
Code - XML-Schema,
auf UModel Elemente, 144
Code Engineering, 54
Assoziationen anzeigen, 61
Importverzeichnis, 61
Komponentenrealisierungen generieren, 137
Projektdatei in neuen Ordner verschieben, 116
Code Generator, 396
Codegenerierung,
Index
© 2010 Altova GmbH
436
Codegenerierung,
Namespace als Verzeichnis verwenden, 54
Color,
syntax coloring - enable/disable, 252
Combined Fragment, 223
Constraint,
in Diagramm hinzufügen, 69
mehreren Elementen zuweisen, 69
Content Model,
des XML-Schemas, 285
Copyright-Informationen, 413
CPU,
Belastung - Statusaktualisierungen im Hintergrundbeschleunigen, 296
CR/LF,
für ump-Datei beim Speichern, 116
csproj - csdproj,
MS Visual Studio .Net, 367
CVS, 296
DDatei, 359
new / load / save - Batch, 114
Tutorial-Beispiel, 12
ump, 116
von URL öffnen, 359
Datei abrufen,
Versionskontrolle, 321
Datei holen,
Versionskontrolle, 320
Dateien,
Beispieldateien, 106
Datentype,
in Schema definieren, 285
Datentypen,
hinzufügen - Autokomplettierung, 93
Deaktiviere Versionskontrolle, 319
Definierte,
Symbole - Code importieren, 123
Deployment,
Diagramm, 50
Symbole, 346
Deployment-Diagramm, 262
Diagram,
- Use Case-Diagramm, 209
Diagramm,
- Aktivitätsdiagramm, 178
- Interaktionsübersichtsdiagramm, 214
- Klassendiagramm, 247
- Profil, 267
Aktivität zu Transition hinzufügen, 193
alle bis auf das aktive schließen, 89
als png speichern, 359
Deployment-Diagramm, 262
Diagrammüberschrift anzeigen, 93
Eigenschaften, 89
Elemente als Bitmap speichern, 364
Elemente aus inkludierten Dateien igrnoieren, 386
Elemente durch Constraint einschränken, 69
Größe anpassen, 89
Hyperlink, 101
Kommunikationsdiagramm, 210
Komponentendiagramm, 261
Kompositionsstrukturdiagramm, 258
Linienbreite, 89
mehrere Klasseninstanzen, 247
mehrere Sequenzdiagramm anhand eines Diagrammsgenerieren, 235
nur in Diagramm einfügen, 95
Objektdiagramm, 263
offene Diagramme mit Projekt speichern, 386
öffnen, 74
Paket und Diagramm freigeben, 149
Paketabhängigkeiten erstellen, 264
Paktediagramm, 264
Quellcodekommentare anzeigen, 89
Sequenzdiagramm, 219
Sequenzdiagramm anhand von Getter / Setter generieren,235
Sequenzdiagramm generieren, 232
Stile, 80
Symbole, 340
XML-Schema, 278
XML-Schema - Import, 279
Zeitverlaufsdiagramm, 238
Zusätzliches - XML-Schema, 277
Zustandsdiagramm, 192
Diagramme, 176
Strukturdiagramme, 246
Verhaltensdiagramme, 177
Diagrammfenster, 89
Diagramm-Struktur, 74
Diffdog,
© 2010 Altova GmbH
Index 437
Diffdog,
für den Vergleich konfigurieren, 310
Dokument,
Hyperlink zu, 101
Dokumentation,
Annotation, 86
relative Links, 170
UML-Projekt generieren, 170
Dokumentation (Register), 86
Download Versionskontroll-Projekt, 317
Drag and Drop,
rechte Maustaste, 98
Drag-and-Drop,
Assoziation mit Ziehpunkten erstellen, 165
Druckaufbereitung,
XMI-Ausgabe, 292
Drucken,
Druckvorschau, 359
Duchsuchen von Registern, 68
Durch Constraint einschränken,
Element, 69
EEigenschaft,
als Assoziation anzeigen, 89, 168
als Lebenslinie typisiert, 221
typisierte - anzeigen, 157
wiederverwenden, 34
Eigenschaften, 78
hinzufügen, 27
Versionskontrolle, 335
Eigenschaftswert,
Standardwert, 273
Eigenschaftswerte, 269
anzeigen, 279
Attribute ein-/ausblenden, 269
Definitionen, 267
Ein-/ausblenden,
Attribute, Operationen, 247
Ein-/Ausschalten,
Kompaktmodus, 279
Einblenden,
ausblenden - Eigenschaftswerte / Attribute, 269
ausblenden - Slot, 247
Einchecken, 325
Einfügen,
Aktion (Aufrufoperation), 179
Aktion (Aufrufverhalten), 179
einfachen Zustand, 193
Elemente, 98
Interaktionsübersichtselemente, 215
Kompositionsstrukturelemente, 258
mit..., 98
nur in Diagramm, 95
Paketdiagrammelemente, 265
Zeitverlaufsdiagrammelemente, 239
Einfügn,
Element in Diagramm, 95
Einführung, 6
Einschränken,
Classifier, 153
Elemente durch Constraint einschränken, 69
Einschränkung,
Syntaxüberprüfung, 367
Einstelllungen,
Synchronisierung, 134
Einstellungen,
Versionskontrolle, 386
Eintrittspunkt,
zu Unterautomat hinzufügen, 198
Einzelmodus,
Autokomplettierung, 93
Element,
Assoziationen beim Importieren, 61
ausgewählte als Bitmap speichern, 364
ausrichten, 93
ausschneiden, kopieren, einfügen, 95
Beziehungen, 162
Constraint zuweisen, 69
Dokumentation generieren, 170
durch Constraint einschränken, 69
Eigenschaften, 78
einfügen, 98
Hierarchie anzeigen, 83
Hyperlink zu Element erstellen, 101
Stile, 80
zu Favoriten hinzufügen, 76
Elemente,
aus Include-Dateien ignorieren, 386
Zustandsdiagramm einfügen, 193
Endbenutzer-Lizenzvereinbarung, 413, 417
Entfernen,
aus Favoriten, 76
Index
© 2010 Altova GmbH
438
Enumeration,
Standardwert, 273
und Stereotype, 273
Erstellen,
getter / setter Methoden, 247
XML-Schema, 289
Erweitern,
alle Klassenbereiche, 247
Pakete reduzieren, 69
Erweiterung,
XMI, 292
Evaluierungszeitraum,
bei Altova Software-Produkten, 416
für Altova-Software-Produkte, 414
von Altova Software-Produkten, 413
Export,
als XMI, 292
Extras, 379
Optionen, 386
Zum Menü 'Extras' hinzufügen, 381
FFavoriten, 76
Fehlende Elemente,
auflisten, 69
Fehler,
Meldungen, 88
Syntaxüberprüfung, 54
Fenster, 393
Standardeinstellungen wiederherstellen, 379
Fensterbereich "Meldungen", 88
Filtertypen,
Autokomplettierungsfenster, 93
Format,
Autokomplettierungsfenster, 93
benutzerdefiniertes Stereotypformat, 275
Forward,
Engineering, 140
Freigeben,
aus Versionskontrolle, 330
Paket und Diagramm, 149
GGate,
Sequenzdiagramm, 226
Gehe zu,
Lebenslinie, 221
Generalisieren,
spezialisieren, 34
Generics,
Unterstützung für Java und C#, 153
Generieren,
Antwortnachricht automatisch generieren, 227
Code von Schema, 396
Komponentenrealisierungen automatisch generieren, 137
mehrere Sequenzdiagramm anhand von Code generieren,235
Sequenzdiagramm anhand von Code, 232
Sequenzdiagramm von Kommunikationsdiagramm, 210
UML-Projektdokumentation, 170
XML-Schema, 289
Geschwindigkeit,
Verbesserung, 159
Get,
getter / setter Methoden, 247
Getter / Setter,
Sequenzdiagramm anhand von Getter / Setter generieren,235
Grafische Ansicht,
einzige Gruppe von Beziehungen, 83
Größe,
Diagrammfenster, 89
HHierarchie,
alle Beziehungen anzeigen, 83
Hierarchiediagramm,
In Dokumentation angezeigte Ebenen, 170
Hilfe, 394
Hintergrund,
Statusaktualisierungen, 310
Statusaktualisierungen - Intervall steigern, 296
Hinzufügen,
Diagramm zu Paket, 18
© 2010 Altova GmbH
Index 439
Hinzufügen,
Einfügen - Löschen aus der Modell-Struktur, 69
Modell-Link, 101
neues Projekt, 116
Paket zu Projekt, 18
Projekt in Versionskontrolle, 327
verschieben - löschen - Diagramm, 89
Versionskontrolle, 327
zu Favoriten, 76
Höhe angleichen,
Höhe - Breite - Größe, 93
Hyperlink, 101
automatischer, 101
IID,
IDs und UUIDs, 292
Ignorieren,
Elemente in Liste, 386
Operationsnamen, 232
Verzeichnisse, 386
Import,
Assoziationselemente, 61
C#-Projekt, 123
Quellprojekt, 61
Verzeichnis, 61
XMI-Datei, 292
XML-Schema, 279
Importieren,
Binärdateien, 128
Projekt, 123
Quellcode, 123
relativ zur UMP-Datei, 123
von UModel generierte XMI-Datei, 292
Inkludieren,
Abhängigkeit, 18
Paket und Diagramm freigeben, 149
Status - ändern, 149
UModel Projekt, 146
Installation,
Ordner examples, 12
Installer,
mehrere Benutzer, 12
Installieren,
Versionskontrollsysteme, 303
Instanz,
Diagramm, 39
mehrere Klassen, Anzeige, 247
Objekt, 39
Intelligentes,
Autokomplettieren, 27
Interaction Use, 226
Interaktinosoperand, 223
Interaktionsoperand,
mehrzeiliger, 223
Interaktionsoperator,
definieren, 223
Interaktionsübersicht,
Elemente einfügen, 215
Interaktionsübersichtsdiagramm, 214
Symbole, 347
Interface,
ball and socket, 247
JJava,
Ausnahmeereignis, 123
Binärdatei importieren, 128
Code, 396
Code und Klassendateinamen, 139
Namespace Root, 140
unterstützte Versionen, 61
JavaDocs, 86
KKatalog,
Datei - XMLSpy Katalogdatei, 386
Klasse, 27
abgeleitete, 34
abgeleitete Klassen einfügen, 98
abstrakte und konkrete, 27
Assoziationen, 27
Autokomplettierungsfenster aktivieren, 386
ball and socket interface, 247
Basis, 34
Basisklasse überschreiben, 247
Eigenschaften hinzufügen, 27
Index
© 2010 Altova GmbH
440
Klasse, 27
erweitern, Bereiche reduzieren, 247
in Komponentendiagramm, 45
mehrere Instanzen in einem Diagramm, 247
Namensänderungen - Synchronisierung, 139
Operation - überschreiben, 247
Operationen hinzufügen, 27
Symbole, 342
Synchronisierung, 134
Klassendiagramm, 247
neues hinzufügen, 27
Klassennamen ändern,
Auswirkung auf Codedateinamen, 139
Knoten,
Stile, 80
Kollaboration,
Kompositionsstrukturdiagramm, 258
Kommentare,
Dokumentation, 86
Quellcodekommentare im Diagramm anzeigen, 89
Kommunikationsdiagramm, 210
Symbole, 343
von Sequenzdiagramm generieren, 210
Kompakt,
Modus - ein-/ausschalten, 279
Kompatibilität,
Projekte aktualisieren, 134
Komponente,
Diagramm, 45
Klasse einfügen, 45
Realisierung, 45
Symbole, 345
Komponentendiagramm, 261
Komponentenrealisierung,
automatische Generierung, 137
Komposition,
Assoziation - erstellen, 27
Kompositionsstruktur,
Elemente einfügen, 258
Kompositionsstrukturdiagramm, 258
Symbole, 344
Konkrete,
Klasse, 27
Kontextmenü,
Befehle, 384
Kopieren,
einfügen in Diagramm, Modell-Struktur, 95
LLabel,
Textlaben ein-/ausblenden, 89, 168
Layout, 377
Lebenslinie,
allgemeiner Wert, 239
Attribute, 221
Eigenschaft vom Typ Lebenslinie, 221
Gehe zu, 221
Linie,
orthogonal, 45
Linien,
formatieren, 39
Stärke/Dicke in Diagrammen, 89
Link,
Hyperlink erstellen, 101
Model-Strukturelement, 101
Links,
relativ zur Dokumentation, 170
Lizenz, 417
Informationen, 413
Lizenzüberwachung,
bei Altova-Produkten, 415
Lokale Dateien,
absolute oder relative Links, 170
Lokales Projekt, 317
Löschen,
aus Favoriten, 76
Befehl aus der Symbolleiste löschen, 380
Befehl aus Kontextmenü, 384
Klassenbeziehung, 162
Symbol aus der Symbolleiste, 380
Symbolleiste, 380
Tastaturkürzel, 384
MMail,
Projekt senden, 359
Manifest,
Artekfakt, 50
Mappen,
© 2010 Altova GmbH
Index 441
Mappen,
C# in/von Modellelementen, 143
Mapping,
VB.NET to/from model elements, 145
XML-Schema von/auf Modellelemente, 144
Maus,
kopieren, einfügen, 95
Mehrere Benutzer,
Ordner examples, 12
Mehrere Elemente,
Stilanzeige, 80
Mehrfachmodus,
Autokomplettierung, 93
Mehrzeilig,
Use Case, 18
Mehrzeiliger,
Akteurtext, 18
Interaktionsoperand, 223
Meine Dokumente,
Beispieldateien, 12
Member End,
Stereotyp, 269
MemberEnd,
Assoziation, 162
Menü,
Anpassen, 384
Ansicht, 378
bearbeiten, 364
Befehl hinzufügen/löschen, 380
Befehle daraus löschen, 384
Datei, 359
Extras, 379
Fenster, 393
Hilfe, 394
Layout, 377
Menü hinzufügen, 381
Projekt, 367
Standardmenü/XMLSPY, 384
Merge,
in Aktivität erstellen, 181
Mergen,
Code aus dem Modell, 54
Metadaten,
XMI-Ausgabe, 292
Methode,
Ausnahmeereignis hinzufügen, 247
mehrere Sequenzdiagramm generieren, 235
Sequenzdiagramm anhand von Getter / Setter generieren,235
Sequenzdiagramm generieren, 232
Methoden,
getter / setter, 247
Mindestvoraussetzungen,
Bedingungen für die Codegenerierung, 140
Modell,
Klassennamen ändern - Auswirkung in Java, 139
Link, hinzufügen, 101
Modell von Code,
Assoziationen anzeigen, 61
Modellieren,
Performance verbessern, 159
Modell-Struktur,
Attribut auswählen, 78
Fensterbereich, 69
Hyperlink zu Element erstellen, 101
Pakete öffnen, 69
MS Visual Source Safe, 296
MS Visual Studio .Net,
csproj - csdproj-Projektdatei, 367
NNachricht,
Aufruf, 227
einfügen, 227
gehe zu Operation, 227
nummerieren, 227
Objekt erstellen, 227
Pfeile, 227
verschieben, 227
Zeitverlaufsdiagramm, 244
Nachrichtenpfeile verschieben, 227
Namespace,
Java Namespace Root, 140
Verwendung für Codegenerierung, 54
Native Oberfläche ausführen, 337
Navigieren,
Hyperlink, 101
Neu,
Classifier, 137
Neue Zeile,
in Lebenslinie, 210
Interaktionsoperand, 223
Index
© 2010 Altova GmbH
442
Nicht verwendete Elemente,
auflisten, 69
Node,
Artefakt hinzufügen, 50
hinzufügen, 50
Nummerieren,
Nachrichten, 227
OObjekt,
Diagramm, 39
Nachricht erstellen, 227
Symbole, 348
Verknüpfungen - Assoziationen, 39
Objektdiagramm, 263
Öffnen,
Diagramm, 74
Pakete in der Baumstrukturansicht, 69
Projekt-Versionskontrolle, 317
URL, 359
Operand,
Interaktion, 223
Operation,
Ausnahmeereignis, 123
Autokomplettierungsfenster, 386
beim Generieren von Sequenzdiagrammen ignorieren, 232
coloring, 252
ein-/ausblenden, 247
gehe zu von Call-Nachricht, 227
überschreiben, 247
Vorlage, 157
wiederverwenden, 34
Operationen,
hinzufügen, 27
Operator,
Interaktion, 223
Optionen,
Extras, 386
Projekt, 158
Versionskontrolle, 386
Ordner,
in Versionskontrolle abrufen, 322
Ordner examples, 12
Ordner abrufen,
Versionskontrolle, 322
Orthogonale,
Linie, 45
Orthogonaler,
Zustand, 198
OwnedEnd,
Assoziation, 162
Ownership,
Punkt, 165
PPaket,
erweitern/reduzieren, 69
freigeben, 149
Profil, 269
Paketdiagramm, 264
Abhängigkeiten erstellen, 264
Elemente einfügen, 265
Symbole, 349
Paketmerge, 265
Pakteimport, 265
Parameter,
Batch, 110
Vorlage, 157
Performance,
Verbesserung, 159
Pfad,
Import relativ zur UMP-Datei, 123
Namespace in Code verwenden, 54
Ordner examples, 12
Projekt verschieben, 116
Projektordner ändern, 116
PNG,
Diagramm speichern, 359
Pretty Print,
Projekt mit Pretty Print speichern, 116
Profil,
- Diagramm, 267
Diagramm, 267
Stereotype, 269
Zuweisung, 267
Projekt, 367
Arbeitsablauf, 116
Datei - aktualisieren, 134
Dokumentation generieren, 170
entfernen aus Versionskontrolle, 329
© 2010 Altova GmbH
Index 443
Projekt, 367
erstellen, 116
Hinzufügen in Versionskontrolle, 327
importieren, 123
letzten beim Starten öffnen, 386
offene Diagramme speichern, 386
Optionen, 158
Paket einfügen, 116
per E-Mail senden, 359
speichern - Pretty Print, 116
Standardcode, 386
Stile, 80
Syntaxüberprüfung, 367
UModel Projekt inkludieren, 146
verschieben, 116
Projekt öffnen,
Versionskontrolle, 317
Projektdateien,
Borland - MS Visual Studio .Net, 367
Property,
coloring, 252
Provider,
auswählen, 317
Punkt,
Ownership, 165
PVCS Version Manager, 296
QQualifier,
Assoziation, 162
Quellcode,
importieren, 123
Quelle,
Codekommentare - im Diagramm anzeigen, 89
RRahmen,
UML-Diagrammüberschrift anzeigen, 93
Raster,
Raster anzeigen, 89
Realisierung,
Komponente, 45
Komponentenrealisierungen generieren, 137
Rechtliches, 413
Rechts ziehen, 98
Reduzieren,
Klassenbereiche, 247
Refactoring,
Klassennamen - Synchronisierung, 139
Referenz, 358
referenzierte Klasse anzeigen, 89
Region,
zu zusammengesetztem Zustand hinzufügen, 198
Relativ,
Dateien importieren/speichern, 123
Relative,
Links, 170
Ressourcen,
Statusaktualisierungen im Hintergrund beschleunigen, 296
Rolle,
Assoziation, 162
Root,
Java Namespace, 140
Katalog - XMLSpy, 386
Paket/Klasse synchronisieren, 134
Round Trip,
Code - Modell -Code, 61
Engineering, 54
Modell - Code - Modell, 54
SSC,
syntax coloring, 252
Schaltflächen,
Sichtbarkeitsschaltflächen, 247
Schema,
Code Generator, 396
Datentype - definieren, 285
XML-Schema, 278
XML-Schema - Import, 279
XML-Schema erstellen, 289
Schließen,
alle Diagramme bis auf das aktive, 89
Schnittstelle,
implementieren, 247
Seite,
Umbruch verhindern, 359
Index
© 2010 Altova GmbH
444
Senden per E-Mail,
Projekt, 359
Sequenz,
Symbole, 351
Sequenzdiagramm, 219
Combined Fragment, 223
Elemente einfügen, 220
Gate, 226
Interaction Use, 226
Lebenslinie, 221
Nachrichten, 227
von Kommunikationsdiagarmm generieren, 210
zu ignorierende Operationsnamen, 232
Zustandsinvariante, 227
Set,
getter / setter Methoden, 247
Setter / Getter,
Sequenzdiagramm generieren, 235
Shortcut, 384
Show,
tagged values, 282
Sichtbarkeit,
Schaltflächen - auswählen, 247
Signatur,
Vorlage, 153, 155
Slot,
ein-/ausblenden, 247
Software-Produktlizenz, 417
Sortieren,
Diagramm, 74
Elemente in der Modell-Struktur, 69
Speicher, 296
Speichern,
Diagramm als Bild speichern, 359
Elemente als Bitmap, 364
Spezialisieren,
generalisieren, 34
SPL, 397
benutzerdefinierte, 134
Codeblöcke, 398
foreach, 407
Standard,
Pfad - Ordner examples, 12
Projektcode, 386
SPL-Vorlagen, 134
Standardmenü,
Menü, 384
Standardwert,
Eigenschaftswert, 269
Star Team, 296
Start,
UModel, 14
Starten,
mit letzten Projekt, 386
Status,
Hintergrundaktualisierungen, 310
Status aktualisieren,
Versionskontrolle, 336
Stereotyp,
Attribute - definieren, 269
benutzerdefinierte Stile, 275
Member End, 269
Profile, 269
Standardeigenschaftswert, 273
und Enumeration, 273
zuweisen, 269
Stereotype,
Definition, 267
Stil,
benutzerdefinierte Stereotypstile, 275
Stile,
cascading Styles, Vorrang, 80
mehrere Auswahlen, 80
Stile (Register), 80
Strg+Leertaste,
Autokomplettierung auf Wunsch, 93
Strukturdiagramme,
Diagramme, 246
Suchen,
Modellierungselemente, 69, 364
nicht verwendete Elemente, 69
Register durchsuchen, 68
Symbol,
Aktivitätsdiagramm, 341
Deployment, 346
groß anzeigen, 385
Klasse, 342
Komponente, 345
Objekt, 348
Sequenz, 351
Verteilung, 346
zur Symbolleiste/zum Menü hinzufügen, 380
Symbole,
definierte - Code importieren, 123
Interaktionsübersichtsdiagramm, 347
Kommunikationsdiagramm, 343
© 2010 Altova GmbH
Index 445
Symbole,
Kompositionsstrukturdiagramm, 344
Paketdiagramm, 349
Use Case, 354
XML-Schemadiagramm, 355
Zeitverlaufsdiagramm, 353
Zustandsdiagramm, 352
Symbolleiste,
aktivieren/deaktivieren, 380
Befehl hinzufügen, 380
große Symbole anzeigen, 385
neue erstellen, 380
Standardeinstellungen wiederherstellen, 379
Symbolleiste & Menübefehle zurücksetzen, 380
Synchronisieren,
Code aus dem Modell übernehmen, 54
mit neuem Ordner, 116
Modell von Code mergen, 61
Root/Paket/Klasse, 134
Synchronisierung,
Änderung von Klassennamen, 139
Einstellungen, 134
Klasse und Codedateinamen, 139
Syntax,
Batch-Datei, 110
Fehler - Warnungen, 54
Projektsyntax überprüfen, 367
überprüfen, 54
Syntax coloring, 252
Syntaxüberprüfung,
Meldungen, 88
TTagged values,
show, 282
Tastaturkürzel,
in Tooltipp anzeigen, 385
zuweisen/löschen, 384
Teilweise Dokumentation,
generieren, 170
Textlabels,
ein-/ausblenden, 89, 168
Tick-Symbol,
Zeitverlaufsdiagramm, 241
Tooltipp,
anzeigen, 385
Tastaturkürzel anzeigen, 385
Transition,
Aktivitätsdiagramm hinzufügen, 193
Trigger definieren, 193
zwischen Zuständen definieren, 193
Trigger,
Transitions-Trigger definieren, 193
Tutorial,
Beispieldateien, 12
Ordner examples, 12
Ziele, 12
Typ,
Eigenschaft - anzeigen, 157
Typen,
und Autokomplettierung, 93
Typisieren,
Eigenschaft - als Lebenslinie, 221
UÜberführen,
Code in Modell, 367
Modell in Code, 367
Überprüfen,
Projektsyntax, 367
Überschreiben,
Code aus Modell, 367
Klassenoperationen, 247
Modell aus Code, 367
Überschrift,
UML-Diagrammüberschrift anzeigen, 93
Übersicht (Fensterbereich), 86
Umbenennen,
Classifier, 137
Umbruch,
Umbruch verhindern, 359
UML,
Diagramm - freigeben, 149
Diagramme, 176
Diagrammüberschrift - anzeigen, 93
Sichtbarkeitsschaltflächen, 247
Vorlagen, 153
UModel,
auf XML-Schema-Code, 144
generierte XMI-Datei importieren, 292
Index
© 2010 Altova GmbH
446
UModel,
in C# Code, 143
starten, 14
to VB.NET code, 145
UModel Diagrammsymbole, 340
UModel Einführung, 6
UMP,
Dateierweiterung, 116
Projektverzeichnis ändern, 116
Unleserlich gemacht,
Unterstützung unleserlich gemachter Binärdateien, 128
Unterautomatenzustand,
neuen Eintrtts-/Austrittspunkt hinzufügen, 198
Unterklasse,
in Diagramm einfügen, 98
Unterschiede anzeigen, 333
URL,
Datei über URL öffnen, 359
Use Case,
Assoziation, 18
Bereiche, 18
hinzufügen, 18
mehrzeilig, 18
Symbole, 354
Use Case diagram, 209
UUID,
Universal Unique Identifiers, 292
Vvalue,
tagged, show, 282
Variablen,
externe Tool-Argumente, 381
VB.NET,
code to model correspondence, 145
Verbessern,
Performance, 159
Vergleichen,
Diffdog konfigurieren, 310
Verhaltensdiagramme, 177
Verlauf,
anzeigen, 331
Verlauf anzeigen, 331
Verschieben,
Projekt, 116
Versionsdateien vergleichen, 333
Versionskontrolle, 296
aktivieren /deaktivieren, 319
aktuellste Version holen, 320
auschecken, 323
Auschecken rückgängig, 326
ausgliedern, 329
Befehle, 316
Datei abrufen, 321
Diffdog Vergleichseditor, 310
Eigenschaften, 335
Einchecken, 325
Hinzufügen in Versionskontrolle, 327
Installationsverfahren, 303
native Oberfläche ausführen, 337
Optionen / Einstellungen, 386
Projekt öffnen, 317
Status aktualisieren, 336
Unterschiede anzeigen, 333
Verlauf anzeigen, 331
Versionskontrollsystem wechseln, 338
Verteilung,
Symbole, 346
Vertrieb,
von Altova Produken, 416
von Altova Software-Produkten, 413
von Altova-Software-Produkten, 414
Verwendung,
Abhängigkeit, 45
Vorlage, 156
Verzeichnis,
beim Zusammenführen igrnoieren, 386
Code importieren, 123
für Codegenerierung, 54
importieren, 61
Namespace in Pfad verwenden, 54
Ordner examples, 12
Projektverzeichnis ändern, 116
Verzweigung,
in Aktivität erstellen, 181
Vollständiger Batch-Modus, 114
Voraussetzungen,
Forward Engineering, 140
Vorlage,
Signatur, 153, 155
Verwendung, 156
Vorlagen,
benutzerdefinierte SPL, 134
© 2010 Altova GmbH
Index 447
Vorlagen,
Operation/Parameter, 157
WWaagrecht anordnen, 93
Warnung,
Meldungen, 88
Syntaxküberprüfung, 54
Web,
Hyperlink, 101
Wert,
Eigenschaftsswert, 269
Werte,
Eigenschaftswerte, 267
Eigenschaftswerte anzeigen, 279
Wertverlaufslinie,
Zeitverlaufsdiagramm, 239
Wiederherstellen,
Symbolleisten und Fenster, 379
XXMI, 292
Druckaufbereitung für die Ausgabe, 292
Erweiterungen, 292
XML-Schema,
Annotation, 279
Content Model, 285
Diagramm, 278
Entsprechung Code - Modell, 144
erstellen/generieren, 289
XML-Schema - Element einfügen, 285
XML-Schemadiagramm,
Symbole, 355
ZZeilenumbruch,
im Akteurtext, 18
Zeitbedingung,
Zeitverlaufsdiagramm, 243
Zeitdauerbedingung,
Zeitverlaufsdiagramm, 243
Zeitlinie,
Zustandsänderungen definieren, 239
Zeitverlaufsdiagramm, 238
auslösendes Ereignis, 242
Elemente einfügen, 239
Lebenslinie, 239
Nachricht, 244
Symbole, 353
Tick-Symbol, 241
wechseln zwischen Typen, 239
Wertverlaufslinie, 239
Zeitbedingung, 243
Zeitdauerbedingung, 243
Zeitlinie, 239
Zentrieren,
Elemente, 93
Ziehpunkt,
Beziehung erstellen, 165
Zoomen,
Größe anpassen, 89
Zurücksetzen,
Menübefehle, 384
Symbolleiste & Menübefehle, 380
Tastaturkürzel, 384
Zusammenführen,
Verzeichnis ignorieren, 386
Zusammengesetzter Zustand, 198
Region hinzufügen, 198
Zustand,
Aktivität hinzufügen, 193
einfachen einfügen, 193
orthogonaler, 198
Transition definieren, 193
Unterautomatenzustand, 198
zusammengesetzter, 198
Zustandsänderungen,
auf einer Zeitlinie definieren, 239
Zustandsdiagramm,
Diagrammelemente, 201
Elemente einfügen, 193
Symbole, 352
zusammengesetzte Zustände, Regionen, 198
Zustände, Aktivitäten, Transitionen, 193
Zustandsdiragramm, 192
Zustandsinvariante, 227
Zuweisen,
Stereotyp, 269
Top Related