XT v4 User Manual German

Dieses Handbuch wurde von Canam Software Labs, Inc. herausgegeben.
Inhalt
Einfhrung 5
bersicht ....................................................................................................................................5 Funktionalitt ............................................................................................................................. 6 Einschrnkungen ........................................................................................................................ 7
Neue Features in XML Thunder Version 4
Erweiterungen des Entwicklungs-Toolsets ................................................................................ 9 nderungen in der Code-Generierung ....................................................................................... 9
Schnellstart: Erstellen eines XML-Handlers
11
bersicht .................................................................................................................... 11 Starten Sie den Assistenten zum Erstellen eines neuen Handlers .............................. 11 Whlen Sie die Quelle fr die XML- und Programm-Datenfeld-Strukturen aus ....... 11 Legen Sie die Eigenschaften des XML-Handlers fest ............................................... 12 Zusammenfassung ..................................................................................................... 13 Das Handler-Design ................................................................................................... 13 Generieren der Handler .............................................................................................. 13 Testen der XML-Handler ........................................................................................... 16
Der New-Handler-Assistent von XML Thunder
17
Starten des Assistenten .............................................................................................. 17 Auswhlen der Quelle ................................................................................................ 17 Entwerfen der IDS ..................................................................................................... 18 Eigenschaften ............................................................................................................. 19 Zusammenfassung ..................................................................................................... 19 Handler-Design-Arten ............................................................................................... 20
Der XML Thunder Designer
21
bersicht .................................................................................................................................. 21 IDS-Fensterausschnitt .............................................................................................................. 22 Registerkarte Logical IDS ......................................................................................... 22 Registerkarte Physical IDS ........................................................................................ 23 XML-Fensterausschnitt ............................................................................................................ 23 Registerkarte Edit XML............................................................................................. 23 Registerkarte Sample ................................................................................................. 23 Registerkarte Schema ................................................................................................ 24 Registerkarte Summary.............................................................................................. 25 Eigenschaften-Fensterausschnitt .............................................................................................. 26 XML-Handler-Funktionen ....................................................................................................... 26 New............................................................................................................................ 26 Open........................................................................................................................... 26 Properties ................................................................................................................... 26 Code Snippets ............................................................................................................ 26 Adopt ......................................................................................................................... 26 Resync IDS ................................................................................................................ 26 Save/Save As ............................................................................................................. 26 Close .......................................................................................................................... 27 IDS-Element-Funktionen ......................................................................................................... 27 Find ........................................................................................................................ 27 Show Mapped ............................................................................................................ 27 Show Unmapped ........................................................................................................ 27 Show All .................................................................................................................... 27 View as Native ........................................................................................................... 28
XML Thunder Einfhrung 1
Transform as ELEMENT
................................................................................. 28
Transform as ATTRIBUTE ............................................................................. 28 Aus- und Einklappen von Listenknoten ..................................................................... 28 Map Data .......................................................................................................... 29
Unmap .............................................................................................................. 29 XML-Element-Funktionen ....................................................................................................... 29 Prfixe fr Knoten ..................................................................................................... 30 Add (XML Item) ........................................................................................................ 30 Add P.I. (Processing Instruction) Node ..................................................................... 30 Add DOCTYPE Node ............................................................................................... 31 Add Comment Node .................................................................................................. 31 Add Element Node..................................................................................................... 31 Add Attribute Node ................................................................................................... 31 Add All Node ............................................................................................................. 31 Add Choice Node ...................................................................................................... 31 Add Sequence Node................................................................................................... 31 Convert ...................................................................................................................... 32 Remove ...................................................................................................................... 32 Undo- und Redo-Funktionen ..................................................................................... 32 Aus- und Einklappen von Listenknoten ..................................................................... 32 Map Data .......................................................................................................... 32
Unmap .............................................................................................................. 33 Tools ........................................................................................................................................ 33 Tools -> Import XML Schema ............................................................................. 33 Tools -> Import WSDL ......................................................................................... 33 Tools -> Import XML Sample .............................................................................. 33 Tools -> Import XML Handler ............................................................................. 33 XML Schema Validation ........................................................................................... 33 XML-Knoten ziehen und ablegen ............................................................................................ 34 Manuelles Abbilden ................................................................................................... 34 Verschieben von XML-Knoten.................................................................................. 34
Code-Generierung
36
Generieren von COBOL- und C-Code....................................................................... 36 COBOL ...................................................................................................................... 38 C ................................................................................................................................ 38 Konsistenz-Prfbericht .............................................................................................. 38 Fehlerbehandlung ..................................................................................................................... 39
XML-Handler-Eigenschaften
43
bersicht .................................................................................................................................. 43 Eigenschaften der Standard-Ebene........................................................................................... 44 Standard-Eigenschaften: General............................................................................... 45 Standard-Eigenschaften: Editor ................................................................................. 46 Standard-Eigenschaften: Formatierung..................................................................... 48 Standard-Eigenschaften: XML-Regeln ...................................................................... 52 Standard-Eigenschaften: IDS-Regeln ....................................................................... 54 Standard-Eigenschaften: Code-Generierung .............................................................. 55 Standard-Eigenschaften: Statuscodes ........................................................................ 59 Standard-Eigenschaften: SOAP ................................................................................. 60 Standard-Eigenschaften: Dictionary .......................................................................... 60 Eigenschaften auf Handler-Ebene ............................................................................................ 61 Handler-Eigenschaften: Allgemein ............................................................................ 62 Handler-Eigenschaften: Formatierung ....................................................................... 63 Handler-Eigenschaften: XML-Regeln ....................................................................... 68 Handler-Eigenschaften: Code-Generierung ............................................................... 69
2 Einfhrung XML Thunder
Handler-Eigenschaften: Statuscodes .......................................................................... 73 Handler-Eigenschaften: SOAP .................................................................................. 73 Eigenschaften auf Knoten-Ebene ............................................................................................. 75 General Properties...................................................................................................... 75 Element / Attribute Properties ................................................................................... 76 Data Value ................................................................................................................. 77 Generierungs-Einstellungen ....................................................................................... 80 IDS-Knoten-Eigenschaften ...................................................................................................... 81
Design bernehmen
82
bersicht .................................................................................................................... 82
Lizenz-Management
84
Aktivieren einer Lizenz ............................................................................................................ 84 Lizenz-Ordner einstellen .......................................................................................................... 86 Software-Aktualisierung ...................................................................................................... 87
Fortgeschrittene Themen
87
XML-Schema-Untersttzung ................................................................................................... 87 Namensrume........................................................................................................................... 88 XML Choice ............................................................................................................................ 89 XML Sequence ........................................................................................................................ 92 XML All................................................................................................................................... 94 XML-BUFFER ........................................................................................................................ 95 Festlegen der XML-Puffer-Gre ............................................................................................ 95 Numerische Zeichenverweise .................................................................................................. 95 Gemischte Inhalte .................................................................................................................... 96 Validierung .............................................................................................................................. 96 Element oder Attribut ............................................................................................................... 96 Wiederholte Strukturen ............................................................................................................ 97 Optionale Elemente und Attribute............................................................................................ 97 Untersttzung von COBOL Redefines ..................................................................................... 98 Untersttzung des Befehls XML PARSE ................................................................................ 99 Handler auf Dokument- und Knoten-Ebene ............................................................................. 99 Handler auf Dokument-Ebene ................................................................................. 100 Handler auf Knoten-Ebene ...................................................................................... 101 XML-Writer auf Knoten-Ebene ............................................................................... 103 XML-Reader auf Knoten-Ebene .............................................................................. 105 XML Thunder Spezialfelder .................................................................................................. 110
XML Thunder
Einfhrung 3
.............. 111 Zhlerfeld ................................................................................................................. 111 Optionales Flag-Feld................................................................................................ 111 Lngenfeld ............................................................................................................... 112 Track-Pointer ........................................................................................................... 112 Erweiterte Genauigkeit ............................................................................................ 112 Generieren von Spezialfeldern in einem separaten Bereich der IDS ....................... 112
Lernprogramme
1. 2. 3. 4. 5. 6. 7. 8. 9.
116
Erstellen eines XML-Handlers unter Verwendung einer COBOL Datenstruktur .... 116 Erstellen eines XML-Handlers unter Verwendung eines XML-Schemas ............... 120 Erstellen eines XML-Handlers unter Verwendung einer XML-Instanz .................. 125 Erstellen eines XML-Handlers unter Verwendung eines COBOL-Programms ....... 131 Erstellen eines Handlers aus einer WSDL ............................................................... 137 Erstellen eines Handlers aus einer DTD .................................................................. 142 Arbeiten mit Spezialfeldern ..................................................................................... 146 Handler mit XML Choice ........................................................................................ 150 Erstellen eines XML-Handlers auf Knoten-Ebene .................................................. 155
Support
164
Technischer Support .............................................................................................................. 164
Bestellmglichkeiten
165
So bestellen Sie XML Thunder .............................................................................................. 165
4 Einfhrung
XML Thunder
Einfhrung
bersicht
XML Thunder stellt Tools bereit, um ein XML-Dokument zu entwerfen und ProgrammDatenelemente bidirektional auf diese XML-Dokumentstruktur abzubilden. Es generiert Code, der als XML-Handler bezeichnet wird und speziell fr das Handling des entworfenen XML-Dokuments beim Lesen und Schreiben dient. Ein XML-Handler ist ein Programm-Modul, das ein XML-Dokument parsen oder erstellen kann. Es besteht aus zwei Teilen: einer IDS (Interface Data Structure) und einem XML-Dokument-Design. Gleich zu Anfang knnen Sie eine IDS-Quelle, eine XML-Quelle oder sogar beides bereitstellen. Eine IDS-Quelle ist der Quellcode eines Programms, wie etwa eines COBOL-Programms, eines COBOL-Copybooks oder einer C-Header-Datei, in der die Schnittstelle beschrieben wird. Eine XML-Quelle ist eine XML-Schema-Datei oder eine XML-Instanz-Datei. Es ist mglich, mit ein und demselben XML-Handler-Design einen XML-Reader (den Parser) oder XML-Writer (den Document Producer) zu generieren. Der Reader/Writer-Code ist nur fr die spezielle Aufgabe zustndig, daher brauchen darin keine umfangreichen Parsing-Funktionen implementiert zu werden, wie sie auf dem heutigen Markt normalerweise in einem XML-Parser enthalten sein mssten. Dadurch wird er im Vergleich zu allgemeinen Implementierungen schneller und kompakter. XML Thunder erstellt den gesamten erforderlichen Code zum Lesen und Schreiben des XMLDokuments. Der Algorithmus des Readers hnelt dem von SAX (Simple API for XML), der fr solche Aufgaben besser geeignet ist und weniger Speicher belegt als DOM-Parser.
XML Thunder
Einfhrung 5
Funktionalitt
Funktionen des Entwicklungstools Intuitiver Entwicklungs-Assistent Einfach zu verwendende visuelle Abbildung von XML auf Programm-Datenfelder Vielseitiger Konverter fr XML nach COBOL- und C-Datenstrukturen Automatische Ableitung eines XML-Schemas aus einem XML-Beispiel Standardeinstellungen fr auftretendes unBounded XML Standardwerte fr XML-Elemente und -Attribute Untersttzung von XML-Auswahlstrukturen Untersttzung von COBOL-Redefines
6 Einfhrung XML Thunder
Automatische Testprogramm-Generierung Sich gegenseitig ausschlieende Strukturen Standardlnge fr unspezifizierte XML-Knoten und max. Rekursionstiefe Benutzerdefinierte Laufzeit-Gewichtung von Fehlercodes Validierung des XML-Schemas schon whrend der Entwurfsphase Funktionen zur automatischen Dokumentationserstellung, um XML-Handler leicht verfolgen und pflegen zu knnen Wrterbuchfunktion zur Normierung von Tag-Namen Generierte Programmfunktionen Leerzeichen-Behandlung (zusammenfassen, erhalten, ersetzen) Es ist nicht ntig, XML-Ereignisse zu behandeln und komplexe Programme dafr zu entwickeln Die aus Ereignissen resultierenden Daten werden automatisch gespeichert und in regulren COBOLVariablen bereitgestellt Automatische Generierung von Programmcode zur Fehlerbehandlung Fortschrittliche XML-Fehlerbehandlung (z.B. unbekannter Knoten, fehlende XML-Knoten, doppelte XML-Attribute, ungltiges Zeichen, Ende des XML-Puffers) Behandlung von Bearbeitungsmustern bei der Konvertierung von XML in die jeweiligen sprachspezifischen Datendomains (Datum, Uhrzeit, Zeitstempel, numerisch) Flexible Datum-, Uhrzeit- und Zeitstempel-Formate Fortschrittliche Fehlerbehandlung fr Bearbeitungsmuster Untersttzung wiederholter COBOL-Strukturen Code-Generierung zur Untersttzung optionaler XML-Knoten Code-Generierung zur Untersttzung von XML-Knoten variabler Lnge Automatische bersetzung numerischer Zeichenverweise ( "" zu "&#xA9") Flexibles Design zur einfachen Integration von XML-Verarbeitungsfunktionen in architektonisch und technisch unterschiedlichen Umgebungen (Batch, CICS, Client-Server, Internet) Weitere Vorteile Hervorragender professioneller Support fr COBOL-Entwickler des Unternehmens Stetige Verbesserungen und neue Funktionen Automatische Verfgbarkeit neuer Software-Versionen whrend der Laufzeit des Wartungsplans Untersttzung von ANSI C und COBOL85 Untersttzt auch HP NonStop (XML Thunder fr HP NonStop), VMS / DEC ALPHA, AS/400 und HP3000-spezifische Dialekte.
Einschrnkungen
Es kann immer nur ein XML-Dokument auf einmal verarbeitet werden XML-Reader und -Writer wurden wie folgt getestet: 90.000.000 Byte XML-Pufferinhalt maximal 90.000 wiederholte Elemente Gemischte Inhalte in XML-Dokumenten werden ignoriert. Verschachtelte wiederholte Strukturen sind bis zu 6 Ebenen tief mglich. Im XML-Dokument kann es in jedem Zweig der Elementhierarchie maximal 6 Elemente geben, deren Eigenschaft fr maximales Vorkommen (Maximum Occurrence) grer als 1 ist. Wenn diese Grenze berschritten wird, werden Reader/Writer berzhlige Flle vom Reader/Writer ignoriert.
XML Thunder
Einfhrung 7
COBOL
Knotennamen drfen hchstens 128 Zeichen lang sein Die folgende Tabelle enthlt untersttzte COBOL-Klauseln: PICTURE 9(n) X(n) S9(n) S9(n)V9(n) USAGE BINARY COMP COMP-1 COMP-2 COMP-3 COMP-4 PACKEDDECIMAL POINTER FILLER REDEFINES VALUE
ausgelassen
ausgelassen
C
Alle Datenfelder mssen innerhalb einer Structure deklariert werden (d.h. struct{...} ) Structures knnen als Arrays definiert werden, auer in der obersten Ebene. Die Gre der Arrays muss innerhalb der Grenzen des Integer-Bereichs liegen. Arrays knnen nur fr "struct"-Definitionen definiert werden Untersttzte Domnen: short int long double char[n+1] (n Zeichen mit einem Null-Abschlusszeichen)
*Untersttzung fr die Sprache C ist auf XML Thunder fr PARSE nicht verfgbar.
XML-Schema
Substitution Groups werden nicht untersttzt. Gemischter Inhalt - ein Element, das sowohl Elemente als auch Inhalte enthlt
8 Einfhrung
XML Thunder
Neue Features in XML Thunder Version 4
Erweiterungen des Entwicklungs-Toolsets

Das Entwickler-Toolset wurde modernisiert, und dadurch konnten Eigenschaftsbltter fr Industrienormen eingefhrt werden. Damit knnen XML- und IDS-Knoten einfacher gepflegt werden. Datenknoten und Spezialfelder wurden zu Eigenschaften eines Elements oder Attributs konvertiert. Das fhrt zu weniger Knoten im XML- und IDS-Design, sodass die Gre der Handler verringert und die Leistung des Toolsets fr groe Handler verbessert wird. "Spezialfelder" in XML Thunder (z.B. Zhler, Flag und Lnge) werden nun automatisch bei Bedarf in die IDS-Struktur eingefgt. Dies wird sogar fr Handler erledigt, die aus ProgrammDatenstrukturen erstellt werden, sodass diese Strukturen nicht mehr manuell gendert zu werden brauchen, um die Spezialfelder zu umfassen, bevor der Handler erstellt wird. Verbesserte manuelle Abbildung von Knoten und "Spezialfeldern" in XML Thunder. Alle Eigenschaften knnen nun auf der jeweiligen Knoten-Ebene gepflegt werden, wobei die Voreinstellungen der Handler berschrieben werden knnen. Frher konnten manche Einstellungen (z.B. Flag-Felder fr optionale Knoten) nur auf der Ebene des Toolsets und Handlers gepflegt werden und andere nur auf der Knoten-Ebene (z.B. vorzeichenbehaftete Zahlen). Eine neugestaltete Benutzeroberflche zur Verwaltung von Toolset-Optionen und HandlerEigenschaften Alle voreingestellten Toolset-Optionen werden nun im Handler gespeichert, wenn er das erste Mal erstellt wird. Dadurch knnen Handler einfacher auf Arbeitsstationen transportiert werden, da sie nicht mehr von den Toolset-Einstellungen einer vorhandenen XML-Thunder-Installation abhngen. Der Name der IDS-Strukturen auf der hchsten Ebene kann nun vom Benutzer definiert werden. Mehrere SOAP-Nachrichten von einem WSDL knnen nun in einem Handler-Design kombiniert werden.
nderungen in der Code-Generierung

Eine neue Generierungsoption "##Compact Code", mit der kleinere und noch effizientere Quellcode-Module erstellt werden knnen. Im generierten Testprogramm werden nun dieselben IDS-Namen verwendet wie im generierten Copybook, sodass es einfacher wird, Programmteile aus dem Testprogramm in Ihr eigenes aufrufendes Programm zu kopieren. Schema-<choice>-Knoten, die Optionen definieren, werden nun untersttzt. In frheren Versionen von XML Thunder wurden alle <choice>-Knoten als "required" behandelt.
Neue Features in XML Thunder Version 4 9
XML Thunder
Verbesserte Untersttzung fr Namensrume in XML-Readern. Verbesserte Fehlerbehandlung und Meldungen in XML-Readern. Untersttzung fr datetime-Knoten, die Zeitzonen in XML-Readern und -Writern enthalten.
10 Neue Features in XML Thunder Version 4
XML Thunder
Schnellstart: Erstellen eines XMLHandlers
bersicht
XML Thunder generiert COBOL- und C-Quellcode zum Lesen oder auch Schreiben von XMLInstanzen. Mit dem Toolset von XML Thunder erstellen Sie ein XML-Handler-Design, in dem die Abbildung zwischen Programm-Datenfeldern und XML-Knoten sowie die anzuwendenden Regeln zur Datenvalidierung spezifiziert sind. Im folgenden Abschnitt werden Sie durch die Erstellung und Generierung eines XML-Handlers gefhrt, damit Sie schnell eine Vorstellung davon bekommen, wie XML Thunder funktioniert.
Starten Sie den Assistenten zum Erstellen eines neuen Handlers

Wenn Sie einen neuen XML-Handler erstellen mchten, starten Sie den XML-Assistenten, indem Sie entweder im Men auf XML-Handler Neu... klicken, oder auf das Symbol in der Symbolleiste (siehe unten)
Whlen Sie die Quelle fr die XML- und Programm-DatenfeldStrukturen aus
XML Thunder
Schnellstart: Erstellen eines XML-Handlers 11
Das Design eines XML-Handlers in XML Thunder beruht auf einer bidirektionalen Abbildung zwischen Programm-Datenfeldern (IDS genannt) und XML-Knoten. Wenn Sie einen neuen XMLHandler erstellen mchten, beginnen Sie damit, dass Sie die Quellen fr diese beiden Datenstrukturen angeben. Sie knnen aus einer Anzahl mglicher IDS- und XML-Kombinationen auswhlen, aber fr dieses Beispiel whlen Sie bitte fr die IDS "Aus XML ableiten" und XML-Struktur -> XSD aus. Besttigen Sie die Auswahl und whlen Sie im Installationsordner von XML Thunder den Unterordner Tutorials aus und dort das Schema "customer.xsd" (z.B. C:\Windows\Programme\canam\XML Thunder\Tutorials\customer.xsd).
Legen Sie die Eigenschaften des XML-Handlers fest

In manchen Schemas kann es mehr als ein mgliches Stammelement geben. In diesem Schema gibt es jedoch nur einen mglichen Stamm, daher knnen wir die Voreinstellung akzeptieren.
12 Schnellstart: Erstellen eines XML-Handlers
XML Thunder
Zusammenfassung
Im Fenster "Zusammenfassung" werden die ausgewhlten Optionen aufgelistet. Klicken Sie auf "Beenden", um die Auswahl zu besttigen und ein XML-Handler-Design zu erstellen.
Das Handler-Design
Wenn Sie auf "Beenden" klicken, wird Ihre Auswahl von XML Thunder verwendet, um das HandlerDesign zu erstellen. In diesem Fall wurden die XML-Struktur und Validierungsregeln unter Verwendung des ausgewhlten Schemas einschlielich etwaiger untergordneter Schemas erstellt, die darin importiert werden. Die Programm-Datenfelder - auch IDS genannt (Interface Data Structure) wurden aus den XML-Knoten abgeleitet. Die XML-Knoten und Programm-Datenfelder wurden automatisch aufeinander abgebildet.
Generieren der Handler

Aus dem Handler-Design kann nun ein XML-Reader oder XML-Writer generiert werden. Wenn Sie mchten, knnen Sie zu Prfzwecken ein Testprogramm und eine IDS-Datei erstellen (Copybook oder C-Header).
XML Thunder Schnellstart: Erstellen eines XML-Handlers 13
Registerkarte "XML-Reader Generation"
Registerkarte "XML-Writer Generation"
Wenn Sie sowohl einen XML-Reader als auch einen XML-Writer generieren mchten und auch das Testprogramm und die Copybook-Dateien, dann werden 6 Quellcode-Dateien erstellt.
XML Thunder
Quellcode XML-Reader
Fr einen XML-Reader wurde der folgende Code generiert: CUSTOMERR - Das XML-Reader-Modul. Dies ist ein COBOL-Unterprogramm. Wenn dieses Programm aufgerufen wird, wird ihm das XML-Dokument in einer Variablen mit dem Namen "XML-BUFFER" bergeben. Der Reader validiert das Dokument, parst die Knoten fr ProgrammDatenfelder und gibt dann diese Felder an das aufrufende Programm in den IDS-Variablen zurck.
CUSTOMERRT - Das Testprogramm fr den XML-Reader. Dies ist ein voll funktionsfhiges Programm, das zum Testen des XML-Readers verwendet wird. Es kann eine XML-Datei einlesen oder mithilfe von Dummy-Datenwerten eine Datei in-line erstellen. Das Testprogramm leitet das XML-Dokument ber die Variable XML-BUFFER an den XML-Reader. Es erhlt den geparsten Inhalt in der IDS zurck (d.h. in den Programm-Datenfeldern). Hinweis: Das Testprogramm ist optional. Es bietet Ihnen eine groartige Mglichkeit, Ihren XMLReader schnell zu testen. Es dient auch als Beispiel, wie Sie den XML-Reader von Ihrem eigenen Programm aus aufrufen knnen.
CUSTOMERRC - Das XML-Reader-Copybook. Dies ist die IDS (Programm-Datenfelder), die als API fr den XML-Reader verwendet wird. Sie ist optional. Weder das Testprogramm noch der XMLReader verwenden das Copybook. Es wird nur zu Ihrer Untersttzung generiert, damit sie es in Ihren Programmen verwenden knnen, um den Reader aufzurufen.
Quellcode des XML-Writers

Fr einen XML-Writer wurde der folgende Code generiert: CUSTOMERW - Das XML-Writer-Modul. Dies ist ein COBOL-Unterprogramm. Wenn Sie dieses Programm aufrufen, bergeben Sie Ihm den XML-Inhalt ber die IDS (d.h. die ProgrammDatenfelder). Der Writer validiert den Inhalt und fgt das XML-Dokument zusammen. Das XMLDokument wird dem aufrufenden Programm ber die Variable XML-BUFFER zurckgegeben.
CUSTOMERWT - Das XML-Writer-Testprogramm. Dies ist ein voll funktionsfhiges Programm, das zum Testen des XML-Writers verwendet wird. Es fllt die IDS (d.h. die Programm-Datenfelder) mit Dummy-Datenwerten auf (x-Reihe fr Zeichen und 9-Reihe fr numerische Werte). Das Testprogramm leitet den XML-Inhalt ber die Programm-Datenfelder an den XML-Writer. Es erhlt das XML-Dokument ber die Variable XML-BUFFER zurck. Hinweis: Das Testprogramm ist optional. Es bietet Ihnen eine groartige Mglichkeit, Ihren XMLWriter schnell zu testen. Es dient auch als Beispiel, wie Sie den XML-Writer von Ihrem eigenen Programm aus aufrufen knnen.
CUSTOMERWC - Das XML-Writer-Copybook. Dies ist die IDS (Programm-Datenfelder), die als API fr den XML-Writer verwendet wird. Sie ist optional. Weder das Testprogramm noch der XMLWriter verwenden das Copybook. Es wird nur zu Ihrer Untersttzung generiert, damit sie es in Ihren Programmen verwenden knnen, um den Writer aufzurufen.
XML Thunder
Schnellstart: Erstellen eines XML-Handlers 15
Testen der XML-Handler

Testen des XML-Readers:
Wenn Sie Ihren XML-Reader testen mchten, kompilieren Sie die Programme CUSTOMERRT und CUSTOMERR. Das CUSTOMERRT (d.h. das Testprogramm) ist das Hauptprogramm. Es ruft das Programm CUSTOMERR auf (d.h. den XML-Reader). Das Copybook ist nicht ntig, um den Handler zu testen.
Testen des XML-Writers:

Wenn Sie Ihren XML-Writer testen mchten, kompilieren Sie die Programme CUSTOMERWT und CUSTOMERW. CUSTOMERWT (d.h. das Testprogramm) ist das Hauptprogramm. Es ruft das Programm CUSTOMERW auf (d.h. den XML-Writer). Das Copybook ist nicht ntig, um den Handler zu testen.
XML Thunder
Der New-Handler-Assistent von XML Thunder
Starten des Assistenten

Der New-Handler-Assistent von XML Thunder fhrt Sie durch die Schritte, die zur Erstellung eines neuen XML-Handler-Designs erforderlich sind. Aus diesem Design knnen Sie dann den COBOLoder C-Code zum Lesen oder Schreiben von XML-Instanzen generieren lassen. Zum Starten des Assistenten klicken Sie im Men auf XML-Handler Neu oder klicken Sie auf das Symbol in der Symbolleiste.
Auswhlen der Quelle

Das Design eines XML-Handlers beruht auf einer bidirektionalen Abbildung zwischen ProgrammDatenfeldern und XML-Knoten. Fr diese Strukturen kann XML Thunder verschiedene Eingabequellen aufnehmen.
Interface Data Structure (IDS)-Quelle Die IDS (oder Programm-Daten-Felder) knnen aus einer der folgenden Quellen bezogen werden:
XML Thunder
Einem COBOL-Copybook oder einer C-Header-Datei Dem Arbeitsspeicherbereich eines vorhandenen COBOL-Programms
Der New-Handler-Assistent von XML Thunder 17
Der XML-Struktur (bzw. aus XML abgeleitet). In diesem Fall werden die ProgrammDatenfelder automatisch auf Grundlage der bereitgestellten XML-Struktur erstellt. Keine. Whlen Sie dies aus, wenn Sie ber keine IDS-Struktur verfgen und die XMLStruktur manuell im Toolset von Grund auf neu erstellen mchten.
Die XML-Struktur-Quelle Die XML-Struktur kann aus einer der folgenden Quellen bezogen werden: Einem XML-Schema (XSD) Eine Dokumenttypdefinition (DTD) Einer Webdienst-Beschreibungssprache (WSDL) Einer Beispiel-XML-Instanz Der IDS (bzw. aus IDS abgeleitet). In diesem Fall werden die XML-Knoten automatisch auf Grundlage der Programm-Datenfelder der bereitgestellten IDS erstellt. Keine. Whlen Sie dies aus, wenn Sie die XML-Struktur manuell im Toolset von Grund auf neu erstellen mchten.
XML Thunder aktiviert und deaktiviert die Kombinationen automatisch auf Grundlage der ausgewhlten Optionen. Zu den blichen Kombinationen gehren: IDS: Datenstruktur XML: XML-Schema und XML: Aus IDS ableiten und IDS: Aus XML ableiten
Entwerfen der IDS

Wenn die IDS-Quelle "Aus vorhandenem Programm ableiten" ausgewhlt ist, wird das Fenster "Design IDS" geffnet. Der Arbeitsspeicher-Abschnitt des ausgewhlten COBOL-Programms wird im linken Fensterausschnitt angezeigt.
Wenn Sie dem Handler-Design Felder hinzufgen mchten, whlen Sie die Felder aus dem Programm (auf der linken Seite) aus und klicken Sie auf ">" (ausgewhltes Feld) oder ">>" (gesamte, unter dem ausgewhlten Feld verschachtelte Datenstruktur). Zum Entfernen von Feldern klicken Sie auf "<" oder "<<".
18 Der New-Handler-Assistent von XML Thunder
XML Thunder
Eigenschaften
Im Eigenschaftenfenster werden Sie nach zustzlichen Informationen ber die ausgewhlten QuellFelder gefragt.
Bezeichner XML-Handler-Name: Wenn der interne Name von XML Thunder verwendet wird, um den XMLHandler zu identifizieren, knnen Sie den vorgegebenen Namen ndern oder beibehalten. (Hinweis: Dieser Name dient nur internen Zwecken und wird nicht an den generierten Code ausgegeben.) Programm-ID: Die Programm-ID, die von XML Thunder an den generierten Code ausgegeben wird. Ein COBOL-Beispiel:
IDS (Interface Data Structure): COBOL-Code-Format: XML Thunder verwendet diese Einstellung fr das Parsen einer COBOLDatenstruktur. Whlen Sie zwischen "Festformat" (zwischen den Spalten 7 und 72) und "Freiformat". XML: Stammelement: (aktiviert, wenn die XML-Quelle ein Schema oder eine DTD ist). In Schemas und DTDs kann mehr als ein Stammelement definiert sein. Whlen Sie das Stammelement fr die XMLStruktur des Handlers aus. SOAP-Nachricht: (aktiviert, wenn die XML-Quelle ein WSDL ist). In einer WSDL kann mehr als eine SOAP-Nachricht definiert sein. Whlen Sie die Nachricht fr die XML-Struktur des Handlers aus. **Beachten Sie, dass Sie mehrere SOAP-Nachrichten in einem Handler-Design kombinieren knnen.
Zusammenfassung
XML Thunder
Der New-Handler-Assistent von XML Thunder 19
Im Fenster "Zusammenfassung" werden die ausgewhlten Optionen aufgelistet. Klicken Sie auf "Beenden", um die Auswahl zu besttigen und ein XML-Handler-Design zu erstellen.
Handler-Design-Arten
Es gibt 3 Arten von Handler-Designs - Locked, In-sync und No-sync. Die Art hngt davon ab, welche Optionen Sie bei der Erstellung des Handlers auswhlen.
Locked - Wenn die IDS-Quelle eine vorhandene Programm-Datenstruktur ist, werden die IDS-Felder im Handler-Design gesperrt (locked). nderungen an der XML-Struktur fhren nicht zu nderungen auf der IDS-Seite des Designs. Wenn zum Beispiel der Name eines XML-Knotens gendert wird, wird dadurch nicht der Name des IDS-Feldes gendert, auf das der Knoten abgebildet wurde. Damit soll sichergestellt werden, dass ein aufrufendes Programm, das dieses Feld verwendet, nicht beeintrchtigt wird. In-Sync - Wenn als IDS-Quelle Aus XML ableiten gewhlt wurde, bleiben die IDS- und XMLStrukturen im Handler-Design synchronisiert (in-sync). Das bedeutet, dass am XML-Design vorgenommene nderungen automatisch in der IDS reflektiert werden. Wenn zum Beispiel der Name eines XML-Knotens gendert wird, wird auch automatisch der entsprechende Feldname in der IDS gendert. No Sync - Wenn als IDS-Quelle Keine gewhlt wurde, wird die IDS-Struktur nur dann aktualisiert, wenn der Befehl "Resync IDS" ausgefhrt wird (im Options-Men des XML-Handlers). Dies funktioniert hnlich wie ein "In-Sync"-Handler, auer dass die IDS- und XML-Strukturen nicht automatisch synchronisiert werden. Stattdessen behlt der Entwickler die Kontrolle darber, wann die IDS synchronisiert wird.
20 Der New-Handler-Assistent von XML Thunder
XML Thunder
Der XML Thunder Designer
bersicht
Mit dem XML Thunder Designer knnen Sie XML-Handler-Definitionen anzeigen, erstellen und bearbeiten. Der Designer hat drei Haupt-Komponenten: 1. 2. 3. Den IDS-Fensterausschnitt, in dem die Datenstruktur der Schnittstelle angezeigt wird Den XML-Fensterausschnitt, in dem die XML-Struktur angezeigt wird Den Eigenschaften-Fensterausschnitt, in dem die Eigenschaften der XML- und IDS-Knoten angezeigt werden
XML Thunder
Der XML Thunder Designer 21
IDS-Fensterausschnitt
XML Thunder untersttzt die Generierung von Code sowohl fr C als auch fr COBOL. Aus diesem Grund wird die Datenstruktur der Schnittstelle per Voreinstellung als eine "Logische IDS" dargestellt. Die Logische IDS ist von der Sprache unabhngig. Wenn Sie die IDS als eine spezielle ProgrammierStruktur anzeigen mchten, klicken Sie auf die Registerkarte "Physical IDS". Dann basiert die angezeigte Struktur auf der aktuellen Spracheinstellung fr die Code-Generierung.
Registerkarte Logical IDS
Symbol markiert eine Datenstruktur Symbol markiert ein Datenfeld Symbol markiert ein abgebildetes Element
22 Der XML Thunder Designer
XML Thunder
Registerkarte Physical IDS
XML-Fensterausschnitt
Registerkarte Edit XML
Die Registerkarte Edit wird verwendet, um die XML-Struktur fr das Handler-Design zu pflegen. XML-Knoten knnen hinzugefgt, gendert und entfernt werden.
Registerkarte Sample
Auf der Registerkarte Sample wird ein Beispiel-XML-Dokument angezeigt, das auf dem aktuellen Design beruht. X stellt fr Datenfeld-Werte dar. Sie knnen speichern oder einen HTML-Browser starten, um die Ansicht zu wechseln.
XML Thunder
Registerkarte Schema
Auf der Registerkarte Schema wird die XML-Schema-Definition auf Grundlage des aktuellen XML-Dokument-Designs angezeigt. Sie knnen speichern oder einen HTML-Browser starten, um die Ansicht zu wechseln. Wenn der aktuelle XML-Handler mit einem XML-Schema als Quelle erstellt wurde, kann das kompilierte Original-Schema durch Klicken auf die Schaltflche Browse Original Schema angezeigt werden.
XML Thunder
Registerkarte Summary
Auf der Registerkarte Summary wird ein zusammenfassender Bericht ber das aktuelle Design angezeigt. Sie knnen dort eine Liste von Datenelementen mit ihren Eigenschaften und Abbildungsinformationen ansehen. Die XML-Dokumentstruktur wird ebenfalls mit Abbildungsinformationen aufgelistet. Klicken Sie auf die Schaltflche Save As, um diesen Bericht als HTML-Datei zu speichern.
XML Thunder
Eigenschaften-Fensterausschnitt
Der Eigenschaften-Fensterausschnitt wird verwendet, um XML- und IDS-Knoteneigenschaften anzuzeigen und zu bearbeiten. Weitere Informationen finden Sie im Abschnitt ber Eigenschaften auf Knoten-Ebene.
XML-Handler-Funktionen
Ein XML-Handler ist das Design-Modell, das Sie im Toolset von XML Thunder erstellen und pflegen. Aus dem Modell knnen Sie Quellcode fr einen XML-Reader oder auch -Writer generieren lassen. Das XML-Handler-Modell wird in einer Datei gespeichert, die XML-Handler-Definition genannt wird.
New
Mit dem Befehl "New" wird der Assistent "New Handler" gestartet, der Sie durch den Erstellungsprozess fr einen neuen XML-Handler fhrt.
Open
Sie knnen vorhandene XML-Handler-Definitionsdateien ffnen, um nderungen an Ihrem Design vorzunehmen. XML-Handler-Definitionsdateien enden mit der Erweiterung .api.xml.
Properties
Die Eigenschaften Standard-Ebene, "Handler-Ebene" und "Knoten-Ebene" knnen fr einen XMLHandler definiert werden. Weitere Informationen finden Sie im Abschnitt ber XML-HandlerEigenschaften.
Code Snippets
Sie knnen Ihren eigenen benutzerdefinierten Code hinzufgen, der beim Starten oder Beenden des Handlers ausgefhrt wird. Ein Code-Abschnitt am Anfang des Handlers kann verwendet werden, um die dem Handler bergebenen Parameter zu ndern, bevor sie verarbeitet werden. Ein CodeAbschnitt am Ende des Handlers kann verwendet werden, um das Ergebnis der Verarbeitung zu ndern, bevor es vom Handler zurckgegeben wird.
Adopt
Die Funktion Adopt wird verwendet, um das Design eines vorhandenen Handlers in einen neuen Handler zu bernehmen. Die bernahme kann nur Locked-Handler erfolgen (Handler, bei deren Erstellung "Datenstruktur" oder "vorhandenes Programm" als IDS-Quelle verwendet wurde).
Resync IDS
Die Funktion "Resync IDS" wird zur erneuten Synchronisierung der IDS-Struktur eines Handlers mit seiner XML-Struktur verwendet. Diese Funktion wird nur bentigt, wenn die IDS- oder XML-Quelle bei der Erstellung des Handlers auf "Keine" eingestellt war.
Save/Save As
Alle XML-Handler werden im aktuellen Ordner gespeichert, der unter "ToolDefault PropertiesGeneral" eingestellt wird. Voreingestellt ist der Unterordner data im Anwendungsordner. Whlen Sie XML-HandlerSave oder Save As aus, um den Handler zu Speichern. Sie werden aufgefordert, einen Dateinamen einzugeben. Bitte beachten Sie, dass der Dateiname nicht auerhalb des Tools umbenannt werden darf, da der Name auch in der Datei selbst gespeichert wird. Wenn sich der Dateiname von dem in der Datei gespeicherten Namen unterscheidet, knnen Probleme beim Laden auftreten.
XML Thunder
Close
Whlen Sie "Close aus, um den aktuellen XML-Handler zu schlieen.
IDS-Element-Funktionen
Die IDS-Menoption beziehen sich auf die Schnittstellen-Datenstruktur-Knoten im Designer. Die IDS-Knoten stellen die Programm-Datenfelder dar, die fr die Schnittstelle zum XML-Handler verwendet werden.
Find
Beim Arbeiten mit groen Handlern kann es schwierig sein, ein bestimmtes IDS-Element zu finden. Wenn Sie in der Symbolleiste auf IDS-Item Find... klicken, wird ein Suchfenster geffnet. Sie knnen ein bestimmtes Element finden, indem Sie seine vollstndige Bezeichnung oder einen Teil davon eingeben.
Show Mapped
Durch diesen Befehl werden abgebildete Elemente in der Liste hervorgehoben. Alle nichtabgebildeten Elemente werden abgeblendet.
Show Unmapped
Durch diesen Befehl werden nicht-abgebildete Elemente in der Liste hervorgehoben. Alle abgebildeten Elemente werden abgeblendet.
Show All
Mit diesem Befehl wird die frhere Show Mapped/Unmapped-Farbgebung wiederhergestellt und alle Elemente bekommen dieselbe Farbe.
XML Thunder
View as Native
Mit der Option "View as Native" werden die IDS-Knoteninformationen im Baum in dem Format angezeigt, das durch die Sprache des Handlers festgelegt ist (Standard: COBOL). Alle Elemente im obigen Beispiel werden mit ihren entsprechenden PIC-Klauseln angezeigt.
Transform as ELEMENT
Wandelt die ausgewhlten Datenelemente in XML-Elemente um. Die Element-Eigenschaften werden in einem Dialogfenster erfasst, bevor der Knoten erstellt wird. Die Abbildungen werden automatisch erstellt. Eine Datenstruktur kann nur dann in ein Ziel-XML-Element umgewandelt werden, wenn alle folgenden Bedingungen erfllt sind: Das XML-Dokument kann ein neues Element oder Attribut an der Zielposition aufnehmen. Wiederholte bergeordnete Datenstrukturen sind bereits derselben Hierarchie entsprechend abgebildet. Wenn eine wiederholte Datenstruktur auf ein XML-Element abgebildet ist, werden ihre untergeordneten Datenstrukturen und Datenfelder zur Abbildung in dieselbe XML-ElementHierarchie verfgbar.
Transform as ATTRIBUTE
Wandelt die ausgewhlten Datenfelder in XML-Attribute um. Die Attribut-Eigenschaften werden in einem Dialogfenster erfasst, bevor der Knoten erstellt wird. Die Abbildungen werden automatisch erstellt.
Aus- und Einklappen von Listenknoten

Sie knnen die Symbole "+" und "-" im IDS-Baum verwenden, um Teile der Baumstruktur aus- oder einzuklappen. Vom Men aus knnen Sie den gesamten Baum an einem bestimmten Punkt aus- oder einklappen. Wenn Sie auf den obersten Knoten im Baum klicken und dann entweder im Baum auf das Symbol zum Einklappen klicken oder auf IDS Item Collapse All, dann wird der gesamte Baum mit einem einzigen Klick eingeklappt. Wenn Sie auf Expand klicken, wird nur eine Ebene unterhalb des Elements, auf dem Sie sich gerade befinden, ausgeklappt. Wenn Sie auf Expand All klicken, wird der gesamte Unter-Baum unterhalb des Elements aufgeklappt, auf dem Sie sich gerade befinden.
XML Thunder
Map Data
Damit wird eine Abbildung zwischen einem ausgewhlten Datenelement und einem XML-Element oder -Attribut erstellt. Nur ein Datenfeld oder eine wiederholte Datenstruktur kann abgebildet werden.
Unmap
Entfernt die Abbildung zwischen den ausgewhlten abgebildeten Daten und XML-Knoten.
XML-Element-Funktionen
Legende: ELEMENT ? zeigt an, dass der Knoten "optional" ist. + zeigt an, dass der Knoten "erweiterbar" ist. }}m:n\\ ### zeigt eine wiederholte Struktur an, wobei m die minimale Anzahl des Vorkommens ist (null bedeutet optional) und "n" ist die maximale Anzahl des Vorkommens ATTRIBUT-Liste ATTRIBUT ? zeigt an, dass der Knoten "optional" ist. ATTRIBUT mit DATEN [...] zeigt das Datenformat an [0..n] zeigt an, dass der Datenknoten eine variable Lnge hat TEXT VERARBEITUNGSANWEISUNG KOMMENTAR DOKUMENT-TYP XML-CHOICE-Struktur XML-SEQUENCE-Struktur
XML Thunder Der XML Thunder Designer 29
XML-ALL-Struktur XML Thunder Spezialfeld
Prfixe fr Knoten
ber dieses Dialogfenster knnen XML-Knoten automatisch mit einem Prfix versehen werden, das hier als Text eingegeben wird. Das Prfix darf nur Buchstaben und Ziffern enthalten (das erste Zeichen darf keine Ziffer sein). Wenn dieses Prfix als Namensraum-Prfix hinzugefgt wird, sollte ein Doppelpunkt (":") als letztes Zeichen verwendet werden (z.B.: Prfix: "MyNameSpace:"). Wenn Sie diese Funktion verwenden mchten, whlen Sie zuerst die Knoten aus, die ein Prfix bekommen sollen (indem Sie bei gedrckter STRG oder UMSCHALTTASTE auf die Knotennamen klicken) und dann "XML Item > Prefix Selected Node(s)" aufrufen.
Add (XML Item)

Sie knnen Ihrem Handler-Design manuell XML-Knoten hinzufgen, indem Sie "XML Item -> Add" aufrufen.
Add P.I. (Processing Instruction) Node

Ein Verarbeitungsanweisungs-Knoten wird oft verwendet, um den XML-Deklarationsknoten fr eine XML-Instanz anzugeben. Fgen Sie dazu einen PI-Knoten hinzu, geben Sie ihm den Namen "xml" und verleihen Sie ihm dann Attribute wie Versionsnummer oder Codierung. Beispiel eines PI-Knotens:
XML Thunder
Hinweis: Auf jeder Ebene kann nur ein PI-Knoten definiert werden.
Add DOCTYPE Node

Ein DOCTYPE-Knoten kann dem Handler-Design manuell hinzugefgt werden. Der DOCTYPE wird den von einem XML-Writer erstellten XML-Instanzen hinzugefgt. Das Hinzufgen eines DOCTYPE-Knotens hat keine Auswirkungen auf einen XML-Writer. Hinweis: Es kann nur ein DOCTYPE erstellt werden und er muss sich auf der obersten Ebene befinden. DOCTYPE-Definitionen werden von XML-Writern ausgegeben. XML-Reader ignorieren die Definition.
Add Comment Node

Ein Kommentar-Knoten kann dem Handler-Design manuell hinzugefgt werden. Der KommentarKnoten wird den von einem XML-Writer erstellten XML-Instanzen hinzugefgt. Das Hinzufgen eines Kommentar-Knotens hat keine Auswirkungen auf einen XML-Reader. Die Eigenschaft Text des Knotens enthlt den eigentlichen Kommentar. Sie knnen den Text fr den Kommentar auch eingeben, indem Sie auf den Knoten selbst doppelklicken.
Add Element Node

Ein XML-Element-Knoten kann dem Handler-Design manuell hinzugefgt werden. Bei InsyncHandlern (Handler, bei deren Erstellung die IDS aus der XML abgeleitet wurde) wird durch das Hinzufgen eines Element-Knotens automatisch auch der zugehrige IDS-Knoten eingefgt.
Add Attribute Node

Ein XML-Attribut-Knoten kann dem Handler-Design manuell hinzugefgt werden. Bei InsyncHandlern (Handler, bei deren Erstellung die IDS aus der XML abgeleitet wurde) wird durch das Hinzufgen eines Attribut-Knotens automatisch auch der zugehrige IDS-Knoten eingefgt.
Add All Node

Ein <all>-Knoten kann dem Handler-Design manuell hinzugefgt werden. Er dient als Verbindung zwischen berund untergeordneten Elementen. Ein <all>-Knoten hnelt einem <sequence>-Knoten, auer dass die Reihenfolge der untergeordneten Knoten direkt unter dem <all> nicht wichtig ist. Weitere Informationen finden Sie im Abschnitt ber XML-All-Untersttzung.
Add Choice Node

Ein <choice>-Knoten kann dem Handler-Design manuell hinzugefgt werden. Ein Choice-Knoten zeigt an, dass nur eines seiner direkt untergeordneten Elemente in einer XML-Instanz vorhanden sein kann. Anders gesagt: Die Auswahlmglichkeiten schlieen sich gegenseitig aus. Weitere Informationen finden Sie im Abschnitt ber XML-Choice-Untersttzung.
Add Sequence Node

Ein <sequence>-Knoten kann dem XML-Handler-Design hinzugefgt werden. Er dient als Verbindung zwischen berund untergeordneten Elementen sowie zum Festlegen einer bestimmten Ordnung, in der seine Elemente in einem XML-Dokument vorgefunden werden sollen. Die untergeordneten Elemente eines <sequence>-Knotens mssen im XML-Dokument in der Reihenfolge auftreten, in der sie aufgelistet sind. Weitere Informationen finden Sie im Abschnitt ber XMLSequence-Untersttzung.
XML Thunder
Convert
Sofern die Bearbeitungsregeln nicht verletzt werden, kann ein XSD-Indikator (<choice>, <all> oder <sequence>) mit der Funktion Convert in einen anderen Indikator konvertiert werden. Wenn Sie zum Beispiel einen <sequence>-Knoten in einen <all>-Knoten konvertieren mchten, klicken Sie mit der rechten Maustaste auf <sequence> und whlen Sie "Convert -> to All node" aus.
Beachten Sie, dass ein Indikator nur dann in einen <all>-Indikator konvertiert werden kann, wenn die unmittelbar berund untergeordneten Elemente keine wiederholten Elemente sind (siehe Untersttzung fr <all>).
Remove
Ein XML-Knoten kann manuell aus dem Handler-Design entfernt werden. Bei Insync-Handlern (Handler, bei deren Erstellung die IDS aus der XML abgeleitet wurde) wird durch das Entfernen eines XML-Knotens automatisch auch der zugehrige IDS-Knoten entfernt.
Undo- und Redo-Funktionen

Bevor der Handler gespeichert wird, kann eine beschrnkte Anzahl von nderungen rckgngig gemacht oder wiederhergestellt werden. Durch den Befehl Save wird der Undo-Stapel geleert. Klicken Sie auf , um den Zustand vor der letzten nderung wiederherzustellen. Das Symbol Undo wird aktiviert, wenn es nderungen gibt, die rckgngig gemacht werden knnen. Klicken Sie auf , um eine vorher rckgngig gemachte nderung wiederherzustellen.
Aus- und Einklappen von Listenknoten

Sie knnen die Symbole "+" und "-" im IDS-Baum verwenden, um Teile der Baumstruktur aus- oder einzuklappen. Vom Men aus knnen Sie den gesamten Baum an einem bestimmten Punkt aus- oder einklappen. Wenn Sie auf den obersten Knoten im Baum klicken und dann entweder im Baum auf das Symbol zum Einklappen klicken oder auf IDS Item Collapse All, dann wird der gesamte Baum mit einem einzigen Klick eingeklappt. Wenn Sie auf Expand klicken, wird nur eine Ebene unterhalb des Elements, auf dem Sie sich gerade befinden, ausgeklappt. Wenn Sie auf Expand All klicken, wird der gesamte Unter-Baum unterhalb des Elements aufgeklappt, auf dem Sie sich gerade befinden.
Map Data
Damit wird eine Abbildung zwischen einem ausgewhlten Datenelement und einem XML-Element oder -Attribut erstellt. Nur ein Datenfeld oder eine wiederholte Datenstruktur kann abgebildet werden.
32 Der XML Thunder Designer XML Thunder
Unmap
Entfernt die Abbildung zwischen den ausgewhlten abgebildeten Daten und XML-Knoten.
Tools
Tools -> Import XML Schema
Eine XML-Schema-Datei kann verwendet werden, um eine XML-Struktur in den aktuellen XMLHandler zu importieren. Ein Dialogfenster Open File wird geffnet, damit Sie eine XML-Schema-Datei (XSD) auswhlen knnen. Klicken Sie auf Open, um die ausgewhlte Datei zu importieren und whlen Sie dann ein Stammelement aus. Die aktuelle XML-Struktur des Handlers wird durch die von Ihnen importierte ersetzt.
Tools -> Import WSDL

Eine Web Services Description Language-Datei kann verwendet werden, um eine XML-Struktur in den aktuellen XML-Handler zu importieren. Ein Dialogfenster Open File wird geffnet, damit Sie eine XML-Schema-Datei (.xsd) auswhlen knnen. Klicken Sie auf ffnen, um die ausgewhlte Datei zu importieren und whlen Sie dann die gewnschte SOAP-Nachricht aus. Die aktuelle XML-Struktur des Handlers wird durch die von Ihnen importierte ersetzt.
Tools -> Import XML Sample

Jede XML-Datei kann als Beispiel verwendet werden, um XML-Strukturen in den aktuellen XMLHandler zu importieren. Ein Dialogfenster Open File wird geffnet, damit Sie eine XML-Datei (.xml) auswhlen knnen. Klicken Sie auf Open, um die ausgewhlte Datei zu importieren. Das aktuelle XML-Design wird ersetzt. Wiederholte Elemente werden gezhlt und ihre Anzahl wird in der Eigenschaft "maximum occurrence" gespeichert. Die Texte von Knoten werden als Text-Knoten erstellt.
Tools -> Import XML Handler

Ein vorhandener XML-Handler kann verwendet werden, um eine XML-Struktur in den momentan geffneten XML-Handler zu importieren. Ein Dialogfenster Open File wird geffnet, damit Sie eine Handler-Definition-Datei (.api..xml) auswhlen knnen. Klicken Sie auf Open, um die ausgewhlte Datei zu importieren. Die aktuelle XML-Struktur des Handlers wird durch die von Ihnen importierte ersetzt.
XML Schema Validation

Das Tool "XML Schema Validation" ermglicht Ihnen, eine oder mehrere XML-Instanz-Dateien whrend des Entwerfens auf Basis einer ausgewhlten XML-Schema-Datei zu validieren.
XML Thunder
Geben Sie eine XML-Schema-Datei vor, indem Sie den vollstndigen Pfad angeben oder auf die Schaltflche Browse klicken. Whlen Sie den Ordner aus, in dem sich die XML-Instanz-Dateien befinden. Whlen Sie eine oder mehrere zu validierende XML-Instanz-Dateien aus. Klicken Sie auf Validate, um die Validierung zu starten. Das Ergebnis der Validierung wird im Protokollfenster angezeigt.
XML-Knoten ziehen und ablegen

Manuelles Abbilden
Ein IDS-Feld kann durch Ziehen und Ablegen auf dem gewnschten XML-Knoten abgebildet werden (und umgekehrt). Ein "Drag"-Symbol zeigt an, ob die Abbildung zulssig ist. XML Thunder prft erst nach dem Ablegen eines Elements auf einem XML-Knoten, ob eine Abbildung tatschlich mglich ist.
Verschieben von XML-Knoten

XML-Elemente knnen innerhalb eines Dokuments verschoben oder kopiert werden, um die Struktur des Dokuments zu ndern. XML-Knoten knnen auch durch Ziehen und Ablegen auf IDS-Felder abgebildet werden. Verschieben von Knoten: Drcken Sie die linke Maustaste whrend sich der Mauszeiger ber einem Knoten befindet und halten Sie die Taste gedrckt, whrend Sie die Maus bewegen. Das Mauszeigersymbol zeigt an, ob der Knoten problemlos zum Zielknoten verschoben werden kann. Kopieren von Knoten: Drcken Sie Strg und die linke Maustaste whrend sich der Mauszeiger ber einem Knoten befindet und halten Sie die Taste gedrckt, whrend Sie die Maus bewegen. Das Mauszeigersymbol zeigt an, ob der Knoten problemlos kopiert und auf dem Zielknoten abgelegt werden kann. untergeordnetes oder gleichgeordnetes Element? Mit der linken Maustaste wird ein gleichgeordnetes Element erstellt. Wenn Sie den Knoten als untergeordnetes Element ablegen mchten, beginnen Sie das Ziehen stattdessen mit der rechten Maustaste.
XML Thunder
bedeutet, dass Sie den Knoten ber den Zielknoten verschieben knnen. bedeutet, dass Sie den Knoten ber den Zielknoten kopieren knnen. bedeutet, dass Sie den Knoten als untergeordnetes Element des Zielknotens verschieben knnen. bedeutet, dass Sie den Knoten als untergeordnetes Element des Zielknotens kopieren knnen. bedeutet, dass Sie den Knoten nicht kopieren oder verschieben knnen.
XML Thunder
Code-Generierung
Generieren von COBOL- und C-Code

Wenn Sie den Code fr den aktuellen XML-Handler generieren mchten, whlen Sie ToolsGenerate... aus oder klicken Sie in der Symbolleiste auf das Generate-Symbol. In beiden Fllen wird ein Dialogfenster geffnet:
Ein XML-Reader und ein XML-Writer knnen aus demselben Handler-Design generiert werden. Wenn Sie Quellcode generieren mchten, whlen Sie zuerst die Registerkarte XML-Reader aus und dann die zu generierenden Quellcode-Module.
36 Code-Generierung
XML Thunder
Language
XML Thunder untersttzt die Generierung von Code sowohl fr C als auch fr COBOL. Fr beide Programmiersprachen kann dasselbe Design zur Generierung verwendet werden.
Target
Bestimmt die angezielte Ausfhrungsumgebung fr den generierten Code.
XML Handler Type

XML Thunder untersttzt zwei Anstze zur Code-Generierung; Dokument-Ebene und Knoten-Ebene.
Generate Compact Code

Ab der Version 4 von XML-Thunder steht ein neuer Kompaktcode-Generator fr XML-Reader zur Verfgung. Der Kompaktcode-Generator erstellt eine kleinere Quellcode-Datei. Er bietet auch die Mglichkeit, den XML-Reader in zwei Module zu spalten (das eine enthlt das Kernprogramm des XML-Readers und das andere das Initialisierungs-Programm). Der Kompaktcode-Generator ist der vorzugsweise zu verwendende Generator. Die Option, einen nicht-kompakten Code zu generieren, steht zur Verfgung, um Handler zu untersttzen, die mit frheren Versionen von XML Thunder erstellt wurden.
XML Reader
Der XML-Reader ist ein aufrufbares Unterprogramm. Er enthlt den Quellcode des Programms zum parsen einer XML-Instanz. Der XML-Reader wird von Ihrem Hauptprogramm aufgerufen (oder vom XML Thunder-Testprogramm). Er nimmt die zu parsende XML-Instanz in der Variablen XMLBUFFER entgegen und gibt den XML-Inhalt in IDS (Programm-Datenfeldern) zurck.
XML Writer
Der XML-Writer ist ein aufrufbares Unterprogramm. Er enthlt den Quellcode des Programms zum Erstellen einer XML-Instanz. Der XML-Writer wird von Ihrem Hauptprogramm aufgerufen (oder vom XML Thunder-Testprogramm). Er erhlt den in der XML-Instanz zu verwendenden Inhalt in Programm-Datenfeldern (IDS) und gibt die zusammengefgte XML-Instanz in der Variable XMLBUFFER zurck.
Use Init File (nur Reader)

Beim Generieren von Kompaktcode knnen Sie optional auch eine init-Datei generieren. Wenn diese Option verwendet wird, wird der XML-Reader in zwei Programme gespalten - das eine enthlt das Kernprogramm und das andere das Initialisierungsprogramm des Handlers.
IDS
Die IDS ist die API zum XML-Reader oder -Writer. Beim Generieren der IDS wird eine CopybookDatei fr COBOL oder eine Header-Datei fr C erstellt. Es ist nicht unbedingt notwendig, die IDS zu erstellen, da die XML-Handler sie nicht verwenden; sie kann jedoch von Ihrem aufrufenden Programm verwendet werden.
Test Harness
Der Test Harness ist ein vollstndig funktionales eigenstndiges Programm, das den XML-Handler aufruft. Er kann verwendet werden, um schnell zu prfen, ob der XML-Handler richtig funktioniert. Er dient auch als Beispiel, wie der XML-Handler aufgerufen werden sollte. Dieses Beispiel knnen Sie in Ihr eigenes aufrufendes Programm kopieren. Zu guter Letzt kann er auch als Ausgangsbasis fr die Erstellung Ihres eigenen Programms zum Lesen oder Schreiben von XML dienen.
Test Harness: More Options

Sie knnen "More Options" auswhlen, um Folgendes zu konfigurieren:
XML Thunder
woher das Testprogramm Inputdaten fr den XML-Handler bekommen soll (aus einer Datei oder aus in-line erzeugten Dummy-Daten) was mit dem Ergebnis des Handlers geschehen soll (in eine Datei schreiben oder anzeigen).
Code-Generierung 37
Read XML from: Gibt an, ob das Testprogramm das XML-Dokument aus einem internen, mit Dummy-Daten gefllten Puffer lesen soll, oder aus einer externen Datei. Output data to: Nach dem Lesen des XML-Dokuments kann das Testprogramm die Daten anzeigen, sie an eine externe sequenzielle Datei senden oder sich ohne Weiteres beenden. Output error log to: Wird verwendet, um auszuwhlen, ob das Fehlerprotokoll in einer sequenziellen Datei gespeichert, auf dem Bildschirm angezeigt oder einfach verworfen werden soll.
COBOL
Der generierte Code ist in einer eigenstndigen Quelldatei mit einer PROGRAMM-ID enthalten, die zum Zeitpunkt der Code-Generierung festgelegt wurde, und in einem FUNKTIONSABSCHNITT, der von einer umgebenden Anwendung aufgerufen werden kann. Das generierte COBOL-Copybook fr die IDS (Interface Data Structure) enthlt alle Datenelemente, die an den XML-Reader oder -Writer bergeben werden mssen. Es ist eine Kopie des VERBINDUNGSABSCHNITTS des generierten Codes. Die in der IDS verwendeten COBOL-Namen werden aus den entsprechenden XML-Element- und Attribut-Namen abgeleitet, wenn der XML-Handler aus einer XML-Instanz oder einem XMLSchema erstellt wird. Andernfalls werden sie aus der verwendeten Quell-IDS abgeleitet. Jeder COBOL-Name kann einen bis zu 6 Zeichen langen festen Text als Prfix erhalten, oder auch bis zu 6 Ziffern als Suffix, um seine Ordnungsnummer oder Ebene darzustellen. Dies wird aus zwei Grnden empfohlen: 1. Um die Eindeutigkeit der Namen zu sichern. (Eindeutige Namen knnen mehrdeutig werden, wenn sie lnger als 31 Zeichen sind und der Generator sie auf die maximal erlaubte Lnge krzt.) 2. Um eventuelle potenziell reservierte Wrter zu beseitigen.
C
Wie bei COBOL ist der generierte C-Code in einer eigenstndigen Quelldatei enthalten, mit einem Funktionsnamen, welcher der bei der Code-Generierung festgelegten Programm-ID entspricht und von einer umgebenden Anwendung aufgerufen werden kann. Die Namen der C-Strukturen und -Variablen sind im Prinzip die gleichen wie in COBOL, nur dass sie nicht gekrzt werden.
Konsistenz-Prfbericht
Der Konsistenz-Prfbericht wird bei der Generierung erstellt, um wertvolle Informationen ber das aktuelle XML-Design zu liefern, das den generierten Code beeintrchtigen knnte. Der Bericht ist obligatorisch und wird erstellt, sobald Sie auf die Schaltflche "Generate" klicken. In diesem Bericht ber den generierten XML-Handler erhalten Sie in folgende Kategorien aufgeteilte Informationen: a) nicht abgebildete XML-Datenknoten b) nicht abgebildete wiederholte XML-Elemente c) nicht verwendete Datenfelder d) Prfung der Choice-Knoten
38 Code-Generierung XML Thunder
Die roten Zeilen sind Hinweise auf Inkonsistenzen, welche die Code-Generierung beeintrchtigen knnen. Das Ergebnis des Berichts dient jedoch nur zur Information und stoppt nicht die Generierung. Der Inhalt des Berichts kann sich in Zukunft aufgrund neu hinzugefgter Funktionen oder auch aufgrund von Kunden-Feedback ndern. Bitte teilen Sie uns mit, welche weiteren Informationen in diesem Bericht enthalten sein sollten.
Fehlerbehandlung
Der integrierte Fehlerbehandlungs-Mechanismus kann bei der Ausfhrung von XML-Handlern Feedback geben. Die XML-Handler-IDS hat die folgende Datenstruktur, um XML-StatusInformationen entgegenzunehmen: COBOL 01 CANAM-XML-STATUS 03 XML-RETURN-CODE PIC X(2). 03 XML-MESSAGE PIC X(80). 03 XML-POSITION PIC S9(9) COMP. 03 XML-SOURCE PIC X(120). C struct canam_xml_status { char xml_return_code[2+1]; char xml_message[80+1]; double xml_position; char xml_source[120+1]; }; Diese Datenstrukturen werden bei der Generierung automatisch in die IDS eingebettet.
Fehlercodes
Code Log Pos OK 1 ER Erfolgreich. Unbekannter Fehler. Tritt auf, wenn ein Vorgang aufgrund einer unerwarteten Bedingung nicht abgeschlossen werden kann. ungltiges Zeichen. Tritt auf, wenn ein unerwartetes Zeichen im Datenstrom angetroffen wird. Beispiel: ein fehlendes "=" nach einem Attributnamen.
Code-Generierung 39
Beschreibung
IC
XML Thunder
3 4
UE UN
Unbekannte Entitt. Tritt auf, wenn eine unbekannte Entitt gefunden wird. Unbekannter Knoten. Tritt auf, wenn ein fremder (unbekannter) Knoten innerhalb eines "nichterweiterbaren" Element-Kontextes angetroffen wird Fehlender Knoten. Tritt auf, wenn ein erforderliches Element oder Attribut fehlt. Doppeltes Attribut. Tritt beim Parsen auf, wenn ein XML-Element zwei Attribute mit gleichen Namen hat. Formatfehler. Der Knotentext entspricht nicht dem Format, das whrend des Designs festgelegt wurde, z. B. be Datum/Uhrzeit-Formaten. Numerischer berlauffehler. Kann auftreten, wenn der ganzzahlige Teil einer Zahl nach dem Parsen verkrzt wird. Puffer-Ende. Tritt beim Parsen auf, wenn das Ende des Puffers erreicht wurde whrend noch weitere Daten erwartet wurden. Fr den Writer bedeutet dies, dass der Puffer erschpft ist, whrend noch weitere Daten ausgegeben werden mussten. Warnmeldung ber weitere Daten. XML-Handler auf Dokument-Ebene: Im XMLDokument befinden sich mehr Daten als die IDS aufnehmen kann. XML-Handler auf Knoten-Ebene: Im XMLDokument befinden sich noch weitere zu lesende oder zu schreibende Daten. Der XML-Handler sollte erneut aufgerufen werden.
5 6
MN DA
PE
OV
EB
10
MD
11 12
NOMD DC
Keine Daten mehr. Doppelte Auswahl. Tritt auf, wenn der XML-Reader mehr als ein XML-Element findet, das einer XMLChoice-Struktur zugeordnet ist. Fehlende Auswahl. Tritt auf, wenn der XML-Reader in einer Choice-Struktur keine Elemente findet. Falscher Parser. Ungltige Aufzhlung. Tritt auf, wenn der Wert eines IDS-Feldes (XML-Writer) oder XML-Elements (XML-Reader) in der Aufzhlungsliste nicht vorkommt. Nillable-Fehler. Tritt auf, wenn die Erzwingung der XML-Nillable-Facette fehlschlgt. Beispiel: <MyField xsi:nill=True>MyContent</MyField> Ungltiger Namensraum. Tritt auf, wenn der XMLReader eine ungltige Namensraum-Deklaration findet ODER wenn ein XML-Element einem nichtdeklarierten Namensraum zugewiesen wird. Knoten nicht in Reihenfolge.
13 14 15
MC BP IE
16
NE
17
IN
18
OS
Anpassung des Schweregrades von Statuscodes

Benutzer knnen den Schweregrad von Fehler- oder Warnmeldungen fr bestimmte, von XMLHandlern verwendete Statuscodes anpassen. Die Schweregrade werden verwendet, um bei der Code40 Code-Generierung XML Thunder
Generierung zwei verschiedene Arten von Fehlerbehandlungscodes zu generieren, die in den Quellcode des XML-Handlers eingefgt werden knnen. Whrend der Laufzeit fhren Statuscodes mit dem Schweregrad Error zu einem sofortigen Abbruch des XML-Handlers, whrend der Statuscode Warning zulsst, dass der XML-Handler weiter ausgefhrt wird. Der erste WarnStatuscode wird an das aufrufende Programm zurckgegeben, wenn kein Fehler auftritt. Weitere Informationen finden Sie im zugehrigen Abschnitt Anpassbare Statuscodes: UN - Unbekannter Knoten MN - Fehlender Knoten DA - Doppeltes Attribut PE - Formatfehler OV - Daten-berlauf MD - Weitere Daten DC - Doppelte Auswahl MC - Fehlende Auswahl IE - Ungltige Aufzhlung NE - Nillable-Fehler IN - Ungltiger Namensraum OS - Knoten nicht in Reihenfolge Folgende Statuscodes haben per Voreinstellung den Schweregrad Error und knnen nicht angepasst werden: ER - Unbekannter Fehler IC - Ungltiges Zeichen UE Unbekannte Entitt EB - Puffer-Ende BP - XML-PARSE-Statement-Error
Arbeiten mit dem Fehlerprotokoll

XML Thunder erstellt ein Fehlerprotokoll, in dem alle Warnungen und Fehlermeldungen gesammelt werden, die bei der Ausfhrung eines XML-Writers oder -Readers auftreten. Es ist wichtig zu beachten, dass Statuscodes mit dem Schweregrad Error die Ausfhrung des XMLHandlers immer sofort abbrechen, weshalb im Fehlerprotokoll nur Daten bis zu diesem Zeitpunkt enthalten sind. Das Fehlerprotokoll ist als wiederholte Struktur definiert, in der sich jedes Auftreten auf einen bestimmten Statuscode bezieht. Jedes Auftreten enthlt Informationen ber einen bestimmten Statuscode. Dazu gehren die Hufigkeit des Auftretens, an welcher Stelle es passiert ist, durch welche Daten es verursacht wurde sowie eine beschreibende Meldung. Wenn das Feld XML-ERROR-COUNT, mit dem berwacht wird, wie oft ein bestimmter Statuscode vorgekommen ist, Null ist, dann wurde dieser Statuscode noch nicht ausgegeben. Das Fehlerprotokoll kann ausgeschaltet werden, indem das Fenster XML-Handler > Properties > Status Codes geffnet und die Option "Generate Log" auf Falsch gesetzt wird. Ein COBOL-Beispiel: Das Fehlerprotokoll sieht wie folgende Struktur aus: 03 XML-LOG OCCURS 25. 05 XML-ERROR-CODE PIC X(2). 05 XML-ERROR-COUNT PIC S9(2). 05 XML-ERROR-POSITION PIC X(200).
XML Thunder Code-Generierung 41
05 XML-ERROR-SOURCE PIC X(500). 05 XML-ERROR-MESSAGE PIC X(500). Bei einer Abfrage des Fehlerprotokolls muss fr jeden XML-ERROR-CODE geprft werden, ob XML-ERROR-COUNT grer als Null ist. Wenn dies zutrifft, werden XML-ERROR-POSITION / SOURCE und MESSAGE nachgesehen. Diese drei Felder sind als "In-Line-Array" aufgebaut und die Teildaten sind durch ein "|"-Zeichen getrennt, das garantiert nicht in den generierten Daten selbst vorkommt. Angenommen, whrend der Ausfhrung eines XML-Readers werden 3 Warnungen ber doppelte Attribute und 2 Warnungen ber unbekannte Knoten ausgegeben. Dann wrde in der XML-LOG-Struktur folgende Werte stehen: XML-ERROR-CODE = "DA" XML-ERROR-COUNT = 3 XML-ERROR-POSITION = "25|364|1483" XML-ERROR-SOURCE = "attr1|attr2|attr3" XML-ERROR-MESSAGE="Duplicate Attribute " XML-ERROR-CODE = "UN" XML-ERROR-COUNT = 2 XML-ERROR-POSITION = "293|924" XML-ERROR-SOURCE = "Dummy1|Dummy2" XML-ERROR-MESSAGE="Unknown Node" In den anderen 23 Positionen stnden deren entsprechende Werte fr XML-ERROR-CODE, XMLERROR-COUNT wre 0 und XML-POSITION / SOURCE / MESSAGE wren leer.
42 Code-Generierung
XML Thunder
XML-Handler-Eigenschaften
bersicht
Die Eigenschaften eines XML-Handlers knnen auf drei Ebenen kontrolliert werden - Standard (oder System), Handler und Knoten. Die Einstellungen der Standard-Ebene (oder System-Ebene) werden verwendet, wenn neue Handler erstellt werden oder wenn einem vorhandenen Handler-Design manuell neue Knoten hinzugefgt werden. Diese Einstellungen werden verwendet, um die Einstellungen der HandlerEbene fr alle neu erstellten Handler zu initialisieren. nderungen an den Eigenschaften der Standard-Ebene wirken sich nur auf neue Knoten aus und haben keinen Einfluss auf schon vorhandene Handler. Die Standard-Eigenschaften knnen ber Tools -> Default Properties gendert werden, oder durch Klicken auf das Symbol "Default Properties" in der Menleiste.
Die Eigenschaften auf Handler-Ebene wirken sich nur auf den aktuellen Handler aus. Diese werden auf Grundlage der Einstellungen der Standard-Ebene initialisiert, wenn der Handler neu erstellt wird. Diese Einstellungen knnen ber XML Handler -> Properties gendert werden, oder durch Klicken auf das Symbol "Handler Properties" in der Menleiste.
Die XML-Eigenschaften auf Knoten-Ebene werden durch die Handler-Eigenschaften initialisiert. Die Eigenschaften auf Knoten-Ebene knnen im Fensterausschnitt XML Properties auf der rechten Seite des Designer-Fensters angezeigt werden. Sie knnen den Eigenschaften-Ausschnitt ein- oder ausblenden, indem Sie mit der rechten Maustaste auf die XML-Seite des Designers klicken und im Kontextmen "Properties" auswhlen, oder indem Sie in der Symbolleiste auf XML Item Properties klicken. Wenn eine Handler-Eigenschaft gendert wird, wird diese nderung fr alle Knoten bernommen, die diese Standard-Eigenschaft verwenden. Bei Knoten, in denen die Standardeinstellungen des Handlers verwendet werden, wird der Ausdruck "(default)" als Teil des Eigenschaftswertes angezeigt. Dies bedeutet, dass ein Knoten mit dem Wert "(default)" seinen Wert aus den HandlerEigenschaften bernimmt (siehe unten). Wenn zum Beispiel der Datumsseparator in der HandlerEbene von "None()" auf "/" gendert wird, bernehmen alle Knoten der Datumsdomne mit dem Separatorwert "default" diesen Eigenschaftswert.
XML Thunder
XML-Handler-Eigenschaften 43
Sie knnen die Handler-Eigenschaften am XML-Knoten berschreiben, indem Sie auf den XMLKnoten klicken und den jeweiligen Wert im Eigenschaften-Fensterausschnitt ndern. Wenn Sie einen "non-default"-Wert fr eine Eigenschaft auswhlen, wird der Eigenschaftswert bei spteren Eigenschafts-nderungen auf Handler-Ebene nicht verndert.
Wenn die IDS die Domnen-Informationen (date, time, timestamp, number) hat, wird fr das Feld automatisch die Standardformatierung verwendet. Folgende Kompatibilittsmatrix kommt zur Anwendung: Feld-Domne Zahl Kompatibles Format Text, Zahl Datum (wenn Lnge >= 8) Uhrzeit (wenn Lnge >= 6) Text Text Zeitstempel (wenn Lnge = 20 oder 26) (Hinweis: Die Lnge 26 kommt zur Anwendung, wenn eine bestimmte Zeitzone zu verwenden ist. Dies bedeutet zum Beispiel, dass ein Zahl-Domnenfeld als Datum formatiert werden kann, wenn die Feldlnge mindestens 8 betrgt. Typenkonvertierungen erfolgen automatisch. Zum Beispiel werden binre COBOL-Felder (COMP) automatisch als Text mit einer passenden Przision und Gre angezeigt. Die Przision und Gre kann auch fr jeden Datenknoten einzeln festgelegt werden.
Eigenschaften der Standard-Ebene

XML Thunder verwaltet eine Reihe Standard-Eigenschaften, mit denen die Einstellungen fr den Betrieb und die Benutzeroberflche des Tools gesteuert werden und auch die Anfangseinstellungen aller neu vom Benutzer erstellten XML-Handler vorgegeben werden. Diese Einstellungen werden fr die Benutzer getrennt verwaltet und initialisiert, wenn XML Thunder zum ersten Mal vom Benutzer gestartet wird. Das Fenster "Default Properties" kann geffnet werden, indem in der Symbolleiste auf das Symbol Default Properties geklickt wird, oder im Men auf Tool Default Properties...
44 XML-Handler-Eigenschaften
XML Thunder
Die Standard-Eigenschaften sind in 9 Kategorien unterteilt: General Editor Formatting XML Rules IDS Rules Code Generation Status Codes SOAP Dictionary Diese Themen werden einzeln in den folgenden Abschnitten behandelt. Das Hauptfenster "Default Properties" wird unten gezeigt. Wenn eine andere Kategorie angeklickt wird, wird eine andere Reihe Eigenschaften angezeigt und zur Bearbeitung verfgbar gemacht. Der Benutzer kann auf die Schaltflche Cancel klicken, um zu vermeiden, dass nderungen wirksam werden.
Standard-Eigenschaften: General
XML Thunder
Der Ordner Current Handler ist der Ordner, in dem alle XML-Handler-Definitionen gespeichert werden. Es ist das erste Verzeichnis, das dem Benutzer vorgelegt wird, wenn er auf das Symbol "Handler Open" klickt. Der Benutzer kann ein anderes Verzeichnis auswhlen, indem er auf die Schaltflche "Browse" klickt. Bei der Verarbeitung eines XML-Handlers knnen einige Warnmeldungs-Fenster erscheinen, die entweder fr die aktuelle Sitzung oder dauerhaft unterdrckt werden knnen. Durch einen Klick auf die Schaltflche "Activate" aktiviert XML Thunder alle unterdrckten Warn- oder Informationsfenster. Ein Beispiel solch eines Dialogfensters wird unten gezeigt.
Standard-Eigenschaften: Editor
Die Standard-Eigenschaften fr den Editor steuern das Aussehen und die Funktion der Benutzeroberflche des XML-Handler-Designers. Diese sind auf zwei Unterkategorien verteilt: General und View.
XML Thunder
Das Kontrollkstchen Mark mapped IDS items bestimmt, ob neben den abgebildeten IDSElementen ein Hkchen angezeigt wird. Das Kontrollkstchen Auto-Highlight mapped nodes bestimmt, ob das einem ausgewhlten IDSoder XML-Knoten entsprechende abgebildete Element automatisch mit einer anderen Hintergrundfarbe hervorgehoben wird. Das Kontrollkstchen Optional nodes shown with ? bestimmt, ob optionale Knoten im XMLBaum mit einem Fragezeichen gekennzeichnet werden. Das Kontrollkstchen Extensible nodes shown with + bestimmt, ob erweiterbare Knoten im XML-Baum mit einem Plus-Zeichen gekennzeichnet werden. Menu font size ist der aktuelle Schriftgrad des Mens. Sie knnen diesen ndern, indem Sie in der Liste eine andere Gre auswhlen. Die Eigenschaften IDS and XML List font size bestimmen die Schriftart und den Schriftgrad in den IDS- und XML-Baumdiagrammen. Sie knnen diese ndern, indem Sie in der Liste eine andere Gre auswhlen. In beiden Diagrammen werden dieselbe Schriftart und derselbe Schriftgrad verwendet. nderungen an diesen Einstellungen treten in Kraft, wenn der nchste Handler geffnet wird.
XML Sample Pane bestimmt, ob der Fensterausschnitt "XML Sample" angezeigt wird.
XML Thunder XML-Handler-Eigenschaften 47
View Schema Panebestimmt, ob der Fensterausschnitt "Schema" angezeigt wird. View Summary Panebestimmt, ob der Fensterausschnitt "Summary" angezeigt wird. View IDS Design bestimmt, ob der Fensterausschnitt "IDS Design" angezeigt wird. View status bar bestimmt, ob die Statusleiste im Fensterausschnitt Edit angezeigt wird. Display COBOL Redefines references on Logical IDS bestimmt, ob Neudefinitionen der COBOLStruktur im Fensterausschnitt "IDS Design" angezeigt werden.
Standard-Eigenschaften: Formatierung
Formatieren von Text
Im Feld Whitespace werden die aktuellen Einstellungen fr die Behandlung von Whitespace-Zeichen angezeigt. Folgende Optionen stehen zur Verfgung: preserve : alle Zeichen wie vorhanden erhalten. Es werden keine Zeichen abgeschnitten.
replace : alle Whitespaces (Tab, Wagenrcklauf, Zeilenvorschub) werden durch Leerzeichen ersetzt. Es werden keine Zeichen abgeschnitten. collapse : zuerst wird ein "replace" durchgefhrt und dann werden berzhlige Leerzeichen entfernt. Entfernt alle Leerzeichen am Anfang und am Ende Maximum length for XML text nodes bestimmt die maximale Lnge von Textknoten, die whrend der Laufzeit von XML-Reader oder -Writer verarbeitet werden knnen. Die empfohlene Einstellung ist 4096.
XML Thunder
Formatieren von Zahlen
Auf dieser Registerkarte knnen Sie das numerische Standardformat fr alle numerischen Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt. Im Dropdown-Feld Decimal knnen Sie das Dezimalzeichen auswhlen. Das Dezimalzeichen kann nur global fr alle Felder des Dokuments eingestellt werden. Sie knnen einen Punkt oder ein Komma auswhlen Mit dem Kontrollkstchen Signed wird fr alle numerischen Knoten ein Vorzeichenfeld eingefgt.
XML Thunder
Formatieren des Datums
Auf dieser Registerkarte knnen Sie das Standard-Datumsformat fr alle als date formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt. Date Type ermglicht dem Benutzer, gregorianisches oder julianisches Datum als Standardformat einzustellen Gregorian Date Sequence: In diesem Dropdown-Feld knnen Sie eine Datums-Reihenfolge fr gregorianische Datumstypen auswhlen. Julian Date Sequence: In diesem Dropdown-Feld knnen Sie eine Datums-Reihenfolge fr julianische Datumstypen auswhlen. Separator: In diesem Dropdown-Feld knnen Sie ein Trennzeichen fr Datumsfelder auswhlen.
Formatierung der Uhrzeit
Auf dieser Registerkarte knnen Sie das Standard-Zeitformat fr alle als time formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt. Sequence: In diesem Dropdown-Feld knnen Sie eine Reihenfolge fr Uhrzeitfelder auswhlen.
50 XML-Handler-Eigenschaften XML Thunder
Separator: In diesem Dropdown-Feld knnen Sie ein Trennzeichen fr Uhrzeitfelder auswhlen.
Formatierung des Zeitstempels
Auf dieser Registerkarte knnen Sie das Standard-Zeitformat fr alle als timestamp formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt, das durch die anderen Eigenschaften in diesem Fenster bestimmt wird. Im Dropdown-Feld Sequence knnen Sie eine Reihenfolge fr Zeitstempel-Felder auswhlen. Zurzeit ist nur eine verfgbar. Im Kombinationsfeld Date and Time Separators knnen Sie Trennzeichen fr Zeitstempel-Felder auswhlen. Das erste ist das Trennzeichen zwischen den Datums- und Uhrzeit-Teilen. Das DateTrennzeichen steht zwischen Tag, Monat und Jahr. Das Time-Trennzeichen steht zwischen Stunde, Minute und Sekunde. Das Milliseconds-Trennzeichen steht zwischen dem Uhrzeit-Teil und dem Millisekunden-Teil eines Zeitstempels. Mit dem Kontrollkstchen im Feld TimeZone kann der Benutzer eine Zeitzonen-Validierung in die XML-Daten einfgen. Die Zeitzonen-Daten werden gem W3C-Norm gendert. Die W3C-Norm erfordert ein "T" als Trennzeichen fr Datum/Uhrzeit und ein Standard-Zeitzonenformat. Das Zeitzonenformat kann entweder ein 5-Zeichen-Offset von der Greenwich Mean Time sein (z.B. +05:00) oder eine Zulu-Zeit (GMT - Bezeichnung von "Z"). Damit XML-Writer W3C-Zeitzonen untersttzen knnen, muss der IDS-Input 26 Zeichen lang sein; 20 fr den Standard-Zeitstempel (JJJJMMTThhmmssmmmmmm) und bis zu 6, um den GMT-Offset aufzunehmen (+05:00). XML-Reader verarbeiten Zeitstempel-Knoten hinsichtlich eines gltigen W3C-Zeitzonenformats. Ein ungltiges Zeitzonenformat lst einen Formatfehler im Reader aus.
XML Thunder
Standard-Eigenschaften: XML-Regeln
XML-Schema
Diese Optionen beziehen sich auf das Importieren eines XML-Schemas. Default for unbounded occurrences ist der voreingestellte Wert fr die maximale Anzahl des Auftretens unbegrenzter XML-Elemente. Der Hchstwert ist 1000. Der Wert muss grer als 1 Default length for xsd:string types wird verwendet, wenn fr xsd:string keine Lnge vorgegeben ist. Der Hchstwert ist 4000. Default length for unspecified types wird fr Felder verwendet, fr die kein Typ und keine Lnge vorgegeben sind. Der Hchstwert ist 4000. Maximum recursive element depth bestimmt, wie viele Ebenen tief die XML-Elemente erstellt werden, wenn die Definition rekursiv ist (z.B. wenn ein untergeordnetes Element auf ein bergeordnetes Element verweist). Der Hchstwert ist 10. Wenn das Kontrollkstchen max/minLength property aktiviert ist, das XML-Schema importiert wird und ein bestimmtes Element oder Attribut diese Eigenschaften hat, wird der zugehrige Datenknoten auf "variable length" eingestellt. Import XML declaration node bestimmt, ob XML-Thunder den XML-Deklarations-Knoten zum XML-Handler hinzufgen soll. (Beispiel fr einen XML-Deklarations-Knoten: <?xml version=1.0?>) Import XML Namespace bestimmt, ob das Tool alle Namensraum-Deklarationen wie im XMLSchema vorgefunden importieren soll. Tipp: Diese Option muss AKTIVIERT sein, wenn XML Thunder "namespace"-Verarbeitungsroutinen zum generierten Code hinzufgen soll. Node selection when creating XML Handler bestimmt, ob XML Thunder das Quell-XML-Schema dynamisch (auf Anforderung) parsen soll. Beim Navigieren durch die XML-Struktur im Fensterausschnitt "Edit" liest XML Thunder automatisch weitere Daten aus dem XML-Schema ein und aktualisiert dementsprechend die XML-Struktur. At generation time ist nur aktiviert, wenn die Option Choose XML Schema nodes to add to XML Handler verwendet wird. Es ermglicht dem Entwickler, XML Thunder so einzurichten, dass alle fehlenden XML-Knoten aus dem Quell-XML-Schema der Struktur des XML-Handlers noch vor der Code-Generierung hinzugefgt werden, oder dass nur die hinzugefgt werden, die auf IDS-Felder abgebildet sind. Die Option Add unmapped nodes to XML Handler veranlasst XML Thunder, vollstndige XMLReader und -Writer zu generieren, was in den meisten Fllen erwnscht ist. Wenn diese Option deaktiviert wird, werden die von einem XML-Writer erstellten Dokumente unvollstndig und die XML-Reader verlieren Ihre Validierungsfunktionen.
XML Attributes
Diese Optionen beziehen sich auf die XML-Nillable-Facette. Namespace used by nil attribute bestimmt, welcher Namensraum dem URI http://www.w3.org/2001/XMLSchema-instance zugeordnet wird. Default values for nillable elements: Benutzer knnen fr die einzelnen untersttzten Datentypen, durch die ein IDS-Feld (XML-Writer) oder XML-Element (XML-Reader) als Nil-Wert betrachtet wird, verschiedene Werte festlegen. Beispiele: Number: 999 Timestamp: 19000101235959000001 Date: 19000101 Time: 235959 Text: empty
XSD Indicators
XML Thunder
Diese Optionen beziehen sich auf die Arbeit mit XML-Choice-Strukturen. Translate COBOL Redefines to XML Choice bestimmt, ob XML Thunder alle RedefinedVariablen in Choice-Strukturen berfhren und die mit Redefines deklarierten Variablen als untergeordnete Elemente dieser Choice-Strukturen hinzufgen soll. Default Choice selection attribute name bestimmt den beim Erstellen oder Importieren von ChoiceStrukturen zu verwendenden Standard-Attributnamen. Default Choice node name bestimmt den Standard-Knotennamen, den XML Thunder beim Erstellen oder Importieren von XML-Choice-Strukturen vergibt. Der Name erhlt immer eine fortlaufende Nummer aus 4 Ziffern als Suffix. (Beispiel: 0001, 0002 )
Standard-Eigenschaften: IDS-Regeln
XML Thunder
Standard-Eigenschaften: Code-Generierung
Allgemein
IDS-Einstellungen
Parameter Prefix ist ein fester Text, der als Prfix fr den Namen der Master-Ebenen-Struktur verwendet wird. (In COBOL wre dies der Name der generierten 01-Ebenen-Struktur.) Prefix ist ein fester Text, der den einzelnen Datenfeldnamen als Prfix vorangestellt werden kann. In generierten Strukturen erhalten alle Datenfelder das gleiche Prfix. Suffix ist ein Text aus 1 bis 6 Ziffern, der an das Ende der einzelnen Datenfeldnamen angehngt wird. Sie haben drei Mglichkeiten zur Auswahl: a) Sequence: die Reihenfolgen-Nummer des Datennamens wird verwendet. Durch diese Option werden eindeutige Namen in der gesamten Datei garantiert. b) Level: die Ebenen-Nummer des Datennamens wird verwendet. c) None: es werden keine Suffixe verwendet.
Min. number of digits kann zwischen 1 und 6 liegen. Die Suffix-Nummer wird so formatiert, dass sie die ausgewhlte Anzahl von Stellen einnimmt, wobei sie mit Nullen aufgefllt wird. Wenn die Nummer lnger wird, wird sie nach Bedarf erweitert. Level Numbers (COBOL only) ermglicht die Anpassung der Ebenen-Nummern, die von der generierten IDS verwendet werden. Initial level: bestimmt den Wert der ersten COBOL-Struktur nach der 01-Ebene. Increment level: bestimmt die fr die geschachtelten Ebenen zu verwendende Schrittweite. Beispiel: (Verwendung von initial level = 03 and increment level = 2) 01 Data 03 InitialLevel 05 FirstNestedLevel 07 SecondNestedLevel
IDS-Struktur ermglicht die Anpassung der Struktur der generierten IDS. Separate Special Fields: Generiert alle Spezialfelder (Zhler, Flags, Lnge und gegenseitig ausschlieende Steuerelemente) als separate IDS-Parameter. Wenn dieser Modus aktiviert ist, bentigen die generierten Handler 4 (vier) Parameter. Datenfelder, Puffer, Status- UND Spezialfelder. Dieser Modus ist erforderlich, wenn die generierte IDS der Original-Datenstruktur so hnlich wie mglich sein soll. Beachten Sie, dass aufrufende Programme Aktualisierungen bentigen knnen, da sich die generierten Namen ndern knnen. Only generate data: Weist XML Thunder an, nur den Daten-Abschnitt der IDS zu generieren. Das bedeutet, dass Puffer, Statuscodes und Spezialfeld-Bereiche nicht zu generieren sind. Dieser Modus ist erforderlich, wenn mehrere XML-Handler aus demselben Hauptprogramm aufgerufen werden. Root as first level IDS field: Wenn die IDS aus einem XML-Schema abgeleitet wird, fgt XML Thunder ein Feld mit dem Namen CANAM-XML-DATA ein, in dem die aus dem XML-Schema fr die IDS abgeleiteten Felder eingekapselt sind. Wenn diese Option auf True gesetzt wird, wird dieses Verhalten deaktiviert.
Aktivieren Sie Convert all names to upper case, damit die generierten Namen alle in Grobuchstaben geschrieben werden. Andernfalls werden Gro- und Kleinbuchstaben verwendet. Beachten Sie, dass die Gesamtlnge eines Datennamens in ANSI COBOL nicht mehr als 30 Zeichen betragen darf, und dass der resultierende Datenname erforderlichenfalls abgeschnitten wird, falls er lnger wrde. Prfix und Suffix werden nach einer ggf. erforderlichen Krzung hinzugefgt. Beispiel: Wenn als Prfix "AB-" eingestellt ist und das Suffix aus 4 Ziffern besteht, sieht das Copybook folgendermaen aus: 01 CANAM-XML-DATA. 03 AB-MY-ELEMENTX-0001. 05 AB-MY-DATAX-0002 PIC X(10). 05 AB-MY-DATAY-0003 PIC X(20). etc.
XML Thunder
COBOL
Use XML PARSE Statement: Wenn diese Option ausgewhlt ist, verwendet der COBOL-XMLReader den Befehl XML PARSE, der von manchen COBOL-Compilern untersttzt wird. *Obligatorische Verwendung unter XML Thunder fr PARSE. Use Extended Storage Wenn diese Option ausgewhlt ist wird COBOL EXTENDED-STORAGE SECTION anstelle von WORKING-STORAGE SECTION verwendet. Reader Ignores Namespaces weist den generierten XML-Reader an, whrend der Tag-Erkennung eventuell vorgefundene Namensraum-Prfixe zu ignorieren. Generate Compact Node weist XML Thunder an, kompakten Code zu generieren. Durch diese Option wird die Anzahl generierter Code-Zeilen wirkungsvoll verringert, aber die Leistung des XMLHandlers kann dadurch beeintrchtigt werden. Diese Option betrifft nur COBOL-XML-Reader auf Dokument-Ebene. Generate END PROGRAM bestimmt, ob der generierte Code das Tag END PROGRAM <programID> ausgibt. Dialect bestimmt den angezielten COBOL-Dialekt. ANSI85 ist die System-Voreinstellung.
COBOL-Compiler-Direktiven
XML Thunder
Das Fenster "Cobol Compiler directives" ermglicht die Eingabe optionaler COBOL-CompilerDirektiven. Diese Zeilen werden am Anfang des generierten Quellcodes eingefgt. Jede Zeile beginnt automatisch im Bereich A. Bitte vergewissern Sie sich, dass kein Konflikt zwischen diesen Direktiven und anderen eingestellten Optionen wie Quote oder Apost entsteht. Generierte Handler (Reader oder auch Writer) und Copybooks knnen verschiedene Stze Compiler-Direktiven erhalten. Wenn XML Thunder fr HP NonStop in diesen Feldern auf das Tag %FILENAME% trifft, wird dieses automatisch durch den Namen der Quelldatei ersetzt.
C-Code
Generate C Interface for COBOL Program Generiert eine Schnittstelle fr COBOL nach C, durch die ein C-Handler von einem COBOLProgramm aus aufgerufen werden kann.
Generate Debug Code Generiert eine Trace-Datei, die vom Support-Team bei Canam Software Labs verwendet werden kann.
XML Thunder
Standard-Eigenschaften: Statuscodes
Die Schweregrade von Fehler- und Warnmeldungen fr bestimmte von XML-Handlern verwendete Statuscodes knnen vom Benutzer angepasst werden. Die Schweregrade werden verwendet, um bei der Code-Generierung zwei verschiedene Arten von Fehlerbehandlungscodes zu generieren, die in den Quellcode des XML-Handlers eingefgt werden knnen. Whrend der Laufzeit fhren Statuscodes mit dem Schweregrad Error zu einem sofortigen Abbruch des XML-Handlers, whrend der Statuscode Warning zulsst, dass der XML-Handler weiter ausgefhrt wird. Der erste WarnStatuscode wird an das aufrufende Programm zurckgegeben, wenn kein Fehler auftritt. Das Krzel im Feld "Code" und die Beschreibung im Feld "Description" knnen nicht gendert werden.
Benutzer knnen den Schweregrad von Fehler- oder Warnmeldungen fr bestimmte, von XMLHandlern verwendete Statuscodes anpassen. Die Schweregrade werden verwendet, um bei der CodeGenerierung zwei verschiedene Arten von Fehlerbehandlungscodes zu generieren, die in den Quellcode des XML-Handlers eingefgt werden knnen. Whrend der Laufzeit brechen Statuscodes mit dem Schweregrad Error die Ausfhrung des XML-Handlers sofort ab, whrend der Statuscode Warning eine weitere Ausfhrung des XML-Handlers zulsst. Der erste Warn-Statuscode wird an das aufrufende Programm zurckgegeben, wenn kein Fehler auftritt.
Als Schweregrad knnen Sie default, Warning (W) oder Error (E) auswhlen. Der Schweregrad "default" bedeutet, dass die in Klammern angezeigte Schweregrad-Einstellung der Systemebene verwendet wird. Klicken Sie auf OK, um zur Hauptliste zurckzukehren.
Standard-Eigenschaften: SOAP
Das SOAP-Namensraum-Prfix, der Namensraum und die Codierungsart werden von XML-Writern bei der Erstellung von SOAP-Nachrichten verwendet. Auch bei der Konvertierung eines Handlers zu einem SOAP-Nachrichten-Handler werden sie verwendet.
Standard-Eigenschaften: Dictionary
Das Dictionary ist eine optionale Funktion, mit der Sie eine Liste von Knotennamen in separaten Dateien speichern und bei der Erstellung von XML-Elementen und -Attributen zum Nachschlagen verwenden knnen. Path and file name of the dictionary program (txd2.exe) enthlt den Pfad und Dateinamen des Wrterbuch-Programms (txd2.exe) von XML Thunder. Application Path enthlt den Speicherort des Wrterbuchs, das zum Nachschlagen verwendet werden soll. Output folder ist der voreingestellte Ausgabeordner fr die generierten Code-Dateien. Bei der Generierung knnen Sie einen anderen Speicherort zuweisen.
Das Kontrollkstchen Generate debug code bestimmt, ob im generierten Code auch Debug/TraceCode enthalten sein soll. Debug/Trace-Code gibt es nur in C-Code. Viewer ist die per Voreinstellung zum Anzeigen des generierten Codes zu verwendende Anwendung, falls keine zugehrige Anwendung vorhanden ist oder diese nicht verwendet werden soll. Das Kontrollkstchen Use associated viewer dient zum Aktivieren oder Deaktivieren der zugehrigen Anwendung, wenn der Benutzer im Fenster zur Code-Generierung auf "View" klickt. Wenn die Option Generated IDS file name may be the same as the handler program aktiviert ist, knnen Sie im Fenster "Generation" dieselben Namen fr die IDS und das Unterprogramm verwenden. Beachten Sie, dass die IDS- und Unterprogramm-Dateien immer unterschiedliche Dateinamen-Erweiterungen haben. Wenn die Option Generate flag field for optional element and attribute aktiviert ist, erstellt XML Thunder automatisch Flag-Felder fr Handler, die aus XML-Schemas oder XML-Instanzen generiert werden. Wenn die Option Generate index attribute for group element aktiviert ist, fgt der XML-Writer automatisch ein Index-Attribut in jede wiederholte Struktur ein. Der Name des Attributs kann vom Benutzer im Dialogfeld "Attribute name..." angepasst werden.
Auswhlen des Verzeichnisses fr den generierten Code
Durchsuchen Sie die Laufwerke und Ordner und whlen Sie einen Ordner aus, in dem der generierte Code gespeichert wird.
Eigenschaften auf Handler-Ebene

Wenn ein XML-Handler in XML Thunder neu erstellt wird, bernimmt er seine grundlegenden Handler-Eigenschaften aus den Standard-Eigenschaften, die vom Benutzer voreingestellt wurden. Sobald die anfnglichen XML-Handler-Eigenschaften eingerichtet wurden, kann der Benutzer jede dieser Eigenschaften fr den einzelnen XML-Handler ndern. Beachten Sie, dass die Eigenschaften vorhandener Handler durch eine nderung an den Standard-Eigenschaften nicht verndert werden. Alle Knoten im XML-Design sind konform zu den in den Handler-Eigenschaften definierten Regeln. Die Eigenschaften einzelner Knoten knnen auf Knoten-Ebene berschrieben werden. Das Eigenschaftenfenster fr XML-Handler kann durch einen Klick auf das Symbol "Handler Properties" in der Symbolleiste geffnet werden (wie unten gezeigt), oder durch Anklicken der Men-Option XML Handler Properties.
XML Thunder
Die XML-Handler-Eigenschaften sind in 6 Kategorien unterteilt: General Formatting XML Rules Code Generation Status Codes SOAP Diese Themen werden einzeln in den folgenden Abschnitten behandelt. Das Hauptfenster "XML Handler Properties" wird unten gezeigt. Wenn eine andere Kategorie angeklickt wird, wird eine andere Reihe Eigenschaften angezeigt und zur Bearbeitung verfgbar gemacht. Der Benutzer kann auf die Schaltflche Cancel klicken, um zu vermeiden, dass die nderungen fr diesen Handler wirksam werden. Der Benutzer kann die Eigenschaften des XML-Handlers auf die StandardEigenschaften zurcksetzen, die an seinem Arbeitsplatz definiert sind, indem er auf die Schaltflche Re-Load Default Values klickt.
Handler-Eigenschaften: Allgemein
XML Thunder
Name ist ein Bezeichner fr den aktuellen Handler und wird auch fr den Dateinamen verwendet. XML Source ist die ursprngliche Quelle, die geparst wurde, um den Handler zu erstellen. IDS Source ist der Name des ursprnglichen Copybooks oder der Struktur, die verwendet wurde, um den Handler zu erstellen. Language ist CBL(COBOL).oder C. Bei Handlern auf Basis eines Schemas oder einer Instanz bleibt dieses Feld leer. Buffer Size zeigt die Byte-Gre des Puffer-Attributs, das in der IDS definiert ist. Wenn keine Gre angegeben wird, wird die maximale Gre verwendet. Diesen Wert sollten Sie erforderlichenfalls zur Aufnahme des gesamten XML-Dokuments vergrern. Recommended minimum/maximum sind Schtzwerte fr die erforderliche Puffergre, um das XML-Dokument aufzunehmen.
Handler-Eigenschaften: Formatierung
Formatierung: Text
Im Feld Whitespace werden die aktuellen Einstellungen fr die Behandlung von Whitespace-Zeichen angezeigt. Folgende Optionen stehen zur Verfgung:
preserve :
alle Zeichen wie vorhanden erhalten. Es werden keine Zeichen abgeschnitten.
replace : alle Whitespaces (Tab, Wagenrcklauf, Zeilenvorschub) werden durch Leerzeichen ersetzt. Es werden keine Zeichen abgeschnitten. collapse : zuerst wird ein "replace" durchgefhrt und dann werden berzhlige Leerzeichen entfernt. Entfernt alle Leerzeichen am Anfang und am Ende. Maximum length for XML text nodes bestimmt die maximale Lnge von Textknoten, die whrend der Laufzeit von XML-Reader oder -Writer verarbeitet werden knnen. Die empfohlene Einstellung ist 4096.
Formatierung: Zahlen
Auf dieser Registerkarte knnen Sie das numerische Standardformat fr alle numerischen Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt. Im Dropdown-Feld Decimal knnen Sie das Dezimalzeichen auswhlen. Das Dezimalzeichen kann nur global fr alle Felder des Dokuments eingestellt werden. Sie knnen einen Punkt oder ein Komma auswhlen. Mit dem Kontrollkstchen Signed wird fr alle numerischen Knoten ein Vorzeichenfeld eingefgt.
XML Thunder
Formatierung: Datum
Auf dieser Registerkarte knnen Sie das Standard-Datumsformat fr alle als date formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt. Date Type ermglicht dem Benutzer, gregorianisches oder julianisches Datum als Standardformat einzustellen Gregorian Date Sequence: In diesem Dropdown-Feld knnen Sie eine Datums-Reihenfolge fr gregorianische Datumstypen auswhlen. Julian Date Sequence: In diesem Dropdown-Feld knnen Sie eine Datums-Reihenfolge fr julianische Datumstypen auswhlen. Separator: In diesem Dropdown-Feld knnen Sie ein Trennzeichen fr Datumsfelder auswhlen.
Formatierung: Zeit
Auf dieser Registerkarte knnen Sie das Standard-Zeitformat fr alle als time formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt.
Sequence: In diesem Dropdown-Feld knnen Sie eine Reihenfolge fr Uhrzeitfelder auswhlen. Separator: In diesem Dropdown-Feld knnen Sie ein Trennzeichen fr Uhrzeitfelder auswhlen.
XML Thunder
Formatierung: Zeitstempel
Auf dieser Registerkarte knnen Sie das Standard-Zeitformat fr alle als timestamp formatierten Felder des aktuellen XML-Handlers einstellen. Im Feld Sample wird das Ergebnis der Formatierung angezeigt, das durch die anderen Eigenschaften in diesem Fenster bestimmt wird. Im Dropdown-Feld Sequence knnen Sie eine Reihenfolge fr Zeitstempel-Felder auswhlen. Zurzeit ist nur eine verfgbar. Im Kombinationsfeld Date and Time Separators knnen Sie Trennzeichen fr Zeitstempel-Felder auswhlen. Das erste ist das Trennzeichen zwischen den Datums- und Uhrzeit-Teilen. Das DateTrennzeichen steht zwischen Tag, Monat und Jahr. Das Time-Trennzeichen steht zwischen Stunde, Minute und Sekunde. Das Milliseconds-Trennzeichen steht zwischen dem Uhrzeit-Teil und dem Millisekunden-Teil eines Zeitstempels. Mit dem Kontrollkstchen im Feld TimeZone kann der Benutzer eine Zeitzonen-Validierung in die XML-Daten einfgen. Die Zeitzonen-Daten werden gem W3C-Norm gendert. Die W3C-Norm erfordert ein "T" als Trennzeichen fr Datum/Uhrzeit und ein Standard-Zeitzonenformat. Das Zeitzonenformat kann entweder ein 5-Zeichen-Offset von der Greenwich Mean Time sein (z.B. +05:00) oder eine Zulu-Zeit (GMT - Bezeichnung von "Z"). Damit XML-Writer W3C-Zeitzonen untersttzen knnen, muss der IDS-Input 26 Zeichen lang sein; 20 fr den Standard-Zeitstempel (JJJJMMTThhmmssmmmmmm) und bis zu 6, um den GMT-Offset aufzunehmen (+05:00). XML-Reader verarbeiten Zeitstempel-Knoten hinsichtlich eines gltigen W3C-Zeitzonenformats. Ein ungltiges Zeitzonenformat lst einen Formatfehler im Reader aus.
XML Thunder
Handler-Eigenschaften: XML-Regeln
XML Rules: Attribute
Die Nillable-Optionen ermglichen dem Benutzer, die Eigenschaften festzulegen, die von NilAttributen im Handler verwendet werden sollen. Das Namespace-Feld bestimmt, welche Zeichenkette als Namensraum fr Nil-Attribute verwendet werden soll. Damit es als reserviertes Schlsselwort betrachtet wird (anstelle eines normalen Attributes), muss das Nil-Attribut einen Namensraum als Prfix erhalten, der auf http://www.w3.org/2001/XMLSchema-instance verweist. Der Benutzer kann auch den Wert festlegen, der in einen Handler eingefgt werden soll, wenn ein Nil-Attribut angetroffen wird. Benutzer knnen fr die einzelnen untersttzten Datentypen, durch die ein IDS-Feld (XML-Writer) oder XML-Element (XML-Reader) als Nil-Wert betrachtet wird, verschiedene Werte festlegen. Das Feld Reader/Writer Attribute quote bestimmt, ob bei der Generierung des XML-Dokuments ein einfaches oder ein doppeltes Anfhrungszeichen als Trennzeichen fr den Attributwert verwendet wird. Das kann fr Reader und Writer getrennt festgelegt werden.
XML-Regeln: XSD-Indikatoren
XML Thunder
Choice "Default selection attribute name" bestimmt den beim Erstellen oder Importieren von ChoiceStrukturen zu verwendenden Standard -Attributnamen. Default Choice attribute value bestimmt, ob der XML-Reader oder -Writer im Attribut-Feld vollstndig qualifizierte Elementnamen oder einfache Elementnamen verwenden soll.
Handler-Eigenschaften: Code-Generierung
Allgemein
Auf dieser Registerkarte knnen Sie verschiedene Optionen festlegen, die den Vorgang der CodeGenerierung und den Fensterausschnitt "Physical IDS" beeinflussen. Die Eigenschaft Language kann ausgewhlt werden, wenn dies ein auto-IDS-Handler ist. Andernfalls wird die Sprache fr den aktuellen XML-Handler angezeigt. Target ist die Ziel-Plattform, auf der der COBOL-Quellcode ausgefhrt wird. XML Handler Type bestimmt, ob XML Thunder normale Handler generieren soll (XML-Handler auf Dokument-Ebene) oder ob Code generiert werden soll, der fr die Verarbeitung von XMLXML Thunder XML-Handler-Eigenschaften 69
Dateien geeignet ist, die unbegrenzte (unbounded) wiederholte Elemente enthalten (XML-Handler auf Knoten-Ebene). Generate Log bestimmt, ob die Array-Struktur der Protokolldatei so generiert werden soll, dass fortschrittliche Fehlerbehandlung untersttzt wird. Include Extended Precision field for decimal values (floating point) bestimmt, ob das Spezialfeld von XML Thunder zur Untersttzung fortschrittlicher Dezimalbehandlung verwendet werden soll. Das Feld fr die Przision von Dezimalzahlen kann verwendet werden, um festzulegen, wie viele Dezimalstellen vom Writer geschrieben oder vom Reader wiedergegeben werden. Include flag field for optional elements and attributes bestimmt, ob XML Thunder das FlagSpezialfeld einschliet, das eine bessere Kontrolle ber optionale Knoten ermglicht. Das Flagfeld kann verwendet werden, um optionale Knoten durch einen XML-Writer zu unterdrcken oder um anzuzeigen, ob ein optionaler Knoten von einem XML-Reader gefunden wurde. Include Code Snippets in the generated code bestimmt, ob der Code-Generator etwaige, dem XML-Handler hinzugefgte Code-Abschnitte einschlieen soll. Generate Compact Code (Readers only) bestimmt, ob ein kurzer, strker komprimierter Quellcode fr den XML-Reader generiert werden soll. Program ID ist der Objektname des generierten Unterprogramms und der Name der Quelldatei. Index Attribute [XML Writer only] bestimmt, ob der XML-Writer automatisch allen wiederholten Strukturen ein Index-Attribut hinzufgen soll. Beispiel: {}<Product OCCURRENCE=2>{} Dies wird hauptschlich zu Testzwecken verwendet und kann dazu fhren, dass das generierte XMLDokument ungltig wird. Im Feld Source Name knnen Sie den Dateinamen des generierten XML-Readers/Writers festlegen. Er kann anders lauten als die Programm-ID. Init File (compact code only) Der Kompaktcode kann fr den XML-Reader in 2 Dateien aufgeteilt werden - das Kernprogramm und ein Modul mit dem Initialisierungs-Programm. IDS (Interface Data Structure) - Source Name ist der Dateiname des Copybooks oder der IncludeDatei, in der die IDS gespeichert wird. Klicken Sie auf More Options um weitere Optionen fr die Generierung der IDS einzustellen. Test Harness - Source Name ist der Dateiname des generierten Testprogramms. Klicken Sie auf More Options um weitere Optionen fr die Generierung des Test Harness einzustellen. Return IDS Size for XML Reader bestimmt, ob der XML-Reader berechnen soll, wie viele Bytes in die IDS eingelesen werden sollen. Diese Information wird dann im Feld IDS-LENGTH der Struktur CANAM-XML-BUFFER zurckgegeben.
Generierungs-Optionen fr den Test Harness
Read XML from: Gibt an, ob das Testprogramm das XML-Dokument aus einem internen, mit Dummy-Daten gefllten Puffer lesen soll, oder aus einer externen Datei. Output data to: Nach dem Lesen des XML-Dokuments kann das Testprogramm die Daten anzeigen, sie an eine externe sequenzielle Datei senden oder sich ohne Weiteres beenden. Output error log to: Wird verwendet, um auszuwhlen, ob das Fehlerprotokoll in einer sequenziellen Datei gespeichert, auf dem Bildschirm angezeigt oder einfach verworfen werden soll.
XML Thunder
Code-Generierung: COBOL
Dialect bestimmt den angezielten COBOL-Dialekt. ANSI85 ist die System-Voreinstellung. Quote/Apost bestimmt, ob ein einfaches oder ein doppeltes Anfhrungszeichen als Trennzeichen fr Zeichenketten verwendet wird. APOST bedeutet einfaches. Use XML PARSE Statement: Wenn diese Option ausgewhlt ist, verwendet der COBOL-XMLReader den Befehl XML PARSE, der von der Sprache IBM Enterprise COBOL untersttzt wird. Use Extended Storage Wenn diese Option ausgewhlt ist wird COBOL EXTENDED-STORAGE SECTION anstelle von WORKING-STORAGE SECTION verwendet. Set Numeric Value as bestimmt, ob Zahlen in der COBOL API als COMP oder PIC 9 deklariert werden. Reader Ignores Namespaces weist den generierten XML-Reader an, whrend der Tag-Erkennung eventuell vorgefundene Namensraum-Prfixe zu ignorieren. Generate code in a single file veranlasst XML Thunder, den gesamten generierten Code in einer einzigen Datei auszugeben. Generate END PROGRAM bestimmt, ob der generierte Code das Tag END PROGRAM <programID> ausgibt. Quote PROGRAM ID bestimmt, ob die Programm-ID in Anfhrungszeichen eingeschlossen wird. Return IDS size for XML Readers <JKR> Translate COBOL 88-level field to XML Enumeration bestimmt, ob die Deklarationen der 88Ebene im ursprnglichen COBOL-Copybook als Grundlage fr das Nachschlagen einer Aufzhlung auf Knoten-Ebene verwendet werden. Translate Numerical Character References: Wenn dieses Kontrollkstchen aktiviert ist, erstellt der XML-Writer automatisch Zeichenverweise fr ASCII-Werte im Bereich von 0x80 bis 0xFF. EBCDIC-Zeichen werden auf die gleiche Weise dargestellt, wenn sie im selben ASCII-Bereich liegen. Der XML-Reader bertrgt auch automatisch Zeichenverweise im Bereich von 0x00 bis 0xFF in ihre entsprechenden Zeichenwerte. Generate Compact Node weist XML Thunder an, kompakten Code zu generieren. Durch diese Option wird die Anzahl generierter Code-Zeilen wirkungsvoll verringert, aber die Leistung des XMLHandlers kann dadurch beeintrchtigt werden.. Generate separate Init file weist XML Thunder an, ein separates Initialisierungsmodul fr den XML-Reader zu generieren. Der XML-Handler ruft das Initialisierungsmodul auf, um das Initialisierungsprogramm auszufhren. Dadurch wird die Gre des Handlers weiter verringert. Diese Option ist nur bei der Generierung von Kompaktcode verfgbar.
XML Thunder
Code-Generierung: COBOL-Compiler-Direktiven
Damit knnen Sie optionale Compiler-Direktiven fr den COBOL-Compiler eingeben. Sie knnen eine oder mehrere am Anfang des generierten Quellcodes einzufgende Zeilen eingeben. Jede Zeile beginnt automatisch im Bereich A. Bitte vergewissern Sie sich, dass kein Konflikt zwischen diesen Direktiven und anderen eingestellten Optionen wie Quote oder Apost entsteht. Generierte Handler (Reader oder auch Writer), Copybooks und Testprogramme knnen verschiedene Stze CompilerDirektiven erhalten. * XML Thunder fr HP NonStop: Wenn bei der Generierung das Tag %FILENAME% angetroffen wird, wird es automatisch durch den Namen der Quelldatei (Source Name) ersetzt. default bedeutet, dass die Einstellungen der Systemebene verwendet werden.
Code-Generierung: C-Code
XML Thunder
Handler-Eigenschaften: Statuscodes
Benutzer knnen den Schweregrad von Fehler- oder Warnmeldungenfr bestimmte, von XMLHandlern verwendete Statuscodes anpassen. Die Schweregrade werden verwendet, um bei der CodeGenerierung zwei verschiedene Arten von Fehlerbehandlungscodes zu generieren, die in den Quellcode des XML-Handlers eingefgt werden knnen. Whrend der Laufzeit brechen Statuscodes mit dem Schweregrad Error die Ausfhrung des XML-Handlers sofort ab, whrend der Statuscode Warningeine weitere Ausfhrung des XML-Handlers zulsst. Der erste Warn-Statuscode wird an das aufrufende Programm zurckgegeben, wenn kein Fehler auftritt. Als Schweregrad knnen Sie default, Warning (W) oder Error (E) auswhlen. Der Schweregrad "default" bedeutet, dass die in Klammern angezeigte Schweregrad-Einstellung der Systemebene verwendet wird. Klicken Sie auf OK, um zur Hauptliste zurckzukehren.
Handler-Eigenschaften: SOAP
XML Handler defines SOAP message bestimmt, ob der aktuelle XML-Handler verwendet wird, um eine SOAP-XML-Nachricht zu definieren. Hierdurch wird XML Thunder veranlasst, die XMLXML Thunder XML-Handler-Eigenschaften 73
Handler automatisch zu modifizieren und die in einer SOAP-Nachricht erforderlichen XMLElemente und Attribute hinzuzufgen. SOAP namespace prefix ermglicht dem Benutzer, das fr den URIhttp://schemas.xmlsoap.org/soap/envelope/ zu verwendende NamensraumPrfix manuell festzulegen (der Standardwert ist "soap"). SOAP encoding style ermglicht dem Benutzer, die Deklaration des SOAP-Codierungs-Attributs zu ndern. Der Standardwert ist http://schemas.xmlsoap.org/soap/encoding.
XML Thunder
Eigenschaften auf Knoten-Ebene

Die meisten Eigenschaften der Handler-Ebene knnen auf der Knoten-Ebene berschrieben werden, indem der XML-Knoten ausgewhlt und der Wert im Eigenschaften-Fensterausschnitt gendert wird. Es gibt zwei Fensterausschnitte fr Knoten-Eigenschaften - "XML Node Properties" und "IDS Field Properties". Im Fensterausschnitt "XML Node Properties" knnen Sie die Eigenschaften des ausgewhlten XML-Knotens ndern. Der Fensterausschnitt "IDS Field Properties" ist schreibgeschtzt und dient zur Anzeige der Eigenschaften des ausgewhlten IDS-Knotens.
General Properties
Type
Bestimmt den Knotentyp. Folgende Knotentypen werden untersttzt: Attribute, All, Choice, Comment, DOCTYPE, Processing Instruction (P.I.) und Sequence.
Name
Knotenname. Den Knotennamen knnen Sie auch durch einen Doppelklick auf den Knoten selbst aktualisieren.
Alias
XML Thunder
Enthlt einen alternativen Text fr den XML-Knotennamen.

Der Alias-Name wird beim Lesen oder Schreiben eines XML-Dokuments nicht anstelle des eigentlichen XML-Knoten-Namens verwendet. Er wird jedoch beim Aufbau eines AuswahlAttributwertes fr Choice-Strukturen verwendet (wenn der Knotenname als Auswahlwert verwendet wird). Das kann hilfreich sein, um einen aussagekrftigeren Wert bereitzustellen.
Element / Attribute Properties

Extensible
Gilt nur fr Elemente. Zeigt an, dass ein Knoten direkte untergeordnete Elemente haben kann, die nicht im Handler-Design definiert sind. Beim Lesen eines XML-Dokuments wird kein Fehler gemeldet, wenn solch ein Element mit einem unbekannten untergeordneten Knoten angetroffen wird.
Min.Occurs
Gilt nur fr XML-Elemente Die minimale Anzahl, die dieses Element in einer XML-Instanz auftreten muss. Stellen Sie fr die erforderliche Anzahl Elemente 1 oder mehr ein. Stellen Sie 0 fr optionale Elemente ein.
Max.Occurs
Gilt nur fr XML-Elemente Die maximale Anzahl, die dieses Element in einer XML-Instanz auftreten darf.
Unbounded
Gilt nur fr XML-Elemente Solch ein unbegrenztes Element darf in einer XML-Instanz beliebig oft auftreten.
Nillable
Gilt nur fr XML-Elemente Zeigt an, dass das Element einen ausdrcklichen Nullwert enthalten darf. Das Attribut xsi:nil wird verwendet.
Namespace
Gilt nur fr XML-Elemente Der zum XML-Element gehrende XML-Namensraum-URI.
Closing Tag
Gilt nur fr XML-Elemente. Gilt nur fr XML-Writer. Zeigt an, dass ein separates schlieendes Tag auf bei leerem Inhalt verwendet werden soll (z.B. <anElement> </anElement>). Wenn der Wert "False" eingestellt ist, wird bei einem Element ohne Inhalt kein schlieendes Tag verwendet (z.B. <anElement anAttribute=text/>).
Mapped
Zeigt an, ob der XML-Knoten auf einen IDS-Knoten abgebildet ist.
XML Thunder
Fixed Value
Bestimmt, ob fr diesen Knoten eine feste Konstante ausgegeben werden soll. Beachten Sie, dass die Eigenschaft "Has Data" auf "False" stehen muss, damit diese Einstellung aktiviert ist.
Required
Gilt nur fr XML-Elemente. Bestimmt, ob das Attribut obligatorisch ist.
Has Data
Zeigt an, ob der XML-Knoten einen Daten-Inhalt hat. Wenn diese Eigenschaft auf "True" gesetzt wird, werden die "Data Value"-Eigenschaften aktiviert.
Data Value
Daten knnen entweder fr einen Element-Knoten definiert werden, oder fr einen Attribut-Knoten. Wenn Sie Daten-Inhalte hinzufgen mchten, setzen Sie die Eigenschaft Has Data auf True. Zustzliche Daten-Eigenschaften speziell fr Daten-Inhalte werden im EigenschaftenFensterausschnitt angezeigt. Je nach Domne des Knotens werden unterschiedliche Eigenschaften angezeigt. Die Standard-Dateneigenschaften des Knotens sind dieselben wie die HandlerEigenschaften. Diese knnen fr jeden Knoten einzeln berschrieben werden. Wenn die HandlerEigenschaften fr einen Knoten in Kraft sind, erhlt der Eigenschaftswert als Suffix den Ausdruck "(default)". Wenn sie berschrieben wurden, haben sie den neuen Eigenschaftswert und werden durch Fettschrift hervorgehoben. Hinweis: Wenn der Knoten die Handler-Eigenschaft "default" verwendet, wird eine nderung der Handler-Eigenschaft in alle Knoten des Dokuments dieser Domne bernommen, die den Wert "default" verwenden. Wenn der Eigenschaftswert auf Knoten-Ebene berschrieben wurde, wird eine nderung des Handler-Eigenschaftswertes fr diesen Knoten nicht bernommen. Sie knnen den Wert der Knoteneigenschaft auf den Handler-Default zurcksetzen, indem Sie im Eigenschaften-Fensterausschnitt die Eigenschaft mit dem Suffix (default) auswhlen.
Text Nodes
Domain bestimmt die Domne des Knotens, in diesem Fall "text". Sample zeigt ein Beispiel, wie die Daten im Knoten formatiert sein wrden. (Read Only) Sie knnen fr die Daten im Knoten entweder Exact Length angeben, oder eine Kombination von Min Length und Max Length, aber nicht beides. Exact Length bestimmt die Lnge, in der die Textdaten ausgegeben werden. Min length for XML text nodes bestimmt die krzeste Lnge, in der die Textdaten ausgegeben werden. Max length for XML text nodes bestimmt die maximale Lnge von Textknoten, die whrend der Laufzeit von XML-Reader oder -Writer verarbeitet werden knnen. Die empfohlene Einstellung ist 4096. Im Feld Whitespace werden die aktuellen Einstellungen fr die Behandlung von Whitespace-Zeichen angezeigt. Folgende Optionen stehen zur Verfgung:
preserve : alle Zeichen wie vorhanden erhalten. Es werden keine Zeichen abgeschnitten. replace : alle Whitespaces (Tab, Wagenrcklauf, Zeilenvorschub) werden durch Leerzeichen ersetzt. Es werden keine Zeichen abgeschnitten. . collapse : zuerst wird ein "replace" durchgefhrt und dann werden berzhlige Leerzeichen entfernt. Entfernt alle Leerzeichen am Anfang und am Ende. . Default Value Ein Standardwert kann einem Datenknoten zugewiesen werden, der zu einem optionalen XML-Element oder XML-Attribut gehrt. Der Standardwert wird nur fr XMLReaderverwendet. Enumeration stellt die Mglichkeit bereit, eine Liste von Werten anzugeben, die fr diesen Datenknoten zulssig sind. Wenn der Datenwert keinem dieser Werte entspricht, wird ein Fehler gemeldet. Sie knnen die Werteliste ndern, indem Sie die Eigenschaft "Enumeration" auswhlen und dann auf das Eingabefeld rechts von der Eigenschaft "Enumeration" klicken. Dann wird ein Dialogfenster geffnet, in dem Sie die Liste der zulssigen Werte eingeben knnen.
Numerische Knoten
Domain bestimmt die Domne des Knotens, in diesem Fall "number". Sample zeigt ein Beispiel, wie die Daten im Knoten formatiert sein wrden. (Schreibgeschtzt) Number Length ist die Gesamtlnge der Zahl, einschlielich Dezimalstellen. Eine Zahl kann maximal 18 Ziffern lang sein. Number Decimal bestimmt die Anzahl der Dezimalstellen der Zahl. Mit dem Kontrollkstchen Signed wird fr alle numerischen Knoten ein Vorzeichenfeld eingefgt. Decimal Character ist das Zeichen, das zur Darstellung des Dezimaltrennzeichens in Zahlen verwendet wird, fr die Dezimalstellen festgelegt wurden. Das Dezimaltrennzeichen wird auf Handler-Ebene festgelegt und kann nicht auf Knoten-Ebene berschrieben werden, daher ist diese Eigenschaft schreibgeschtzt. Das Zeichen kann entweder ein Punkt oder ein Komma sein. Default Value ist der Datenwert aus der Aufzhlungsliste, der verwendet wird, falls das aufrufende Programm keine Daten liefert. Enumeration stellt die Mglichkeit bereit, eine Liste von Werten anzugeben, die fr diesen Datenknoten zulssig sind. Wenn der Datenwert keinem dieser Werte entspricht, wird ein Fehler gemeldet. Sie knnen die Werteliste ndern, indem Sie die Eigenschaft "Enumeration" auswhlen und dann auf das Eingabefeld rechts von der Eigenschaft "Enumeration" klicken. Dann wird ein Dialogfenster geffnet, in dem Sie die Liste der zulssigen Werte eingeben knnen.
XML Thunder
Datums-Knoten
Domain bestimmt die Domne des Knotens, in diesem Fall "date". Sample zeigt ein Beispiel, wie die Daten im Knoten formatiert sein wrden. (Schreibgeschtzt) Date Sequence ist die Reihenfolge von Jahr, Monat und Tag, die in diesem Datenknoten verwendet wird.. Date Separator ist das Trennzeichen, das zwischen den Teilen eines Datums verwendet wird. Date Type bestimmt den Datumstyp (gregorianisch oder julianisch), der in diesem Datums-Knoten verwendet wird.
Uhrzeit-Knoten
Domain bestimmt die Domne des Knotens, in diesem Fall "time". Sample zeigt ein Beispiel, wie die Daten im Knoten formatiert sein wrden. (Schreibgeschtzt) Time Sequence ist die Reihenfolge von Stunden, Minuten und Sekunden, die in diesem Datenknoten verwendet wird.. Time Separator ist das Trennzeichen, das zwischen den Teilen einer Uhrzeit verwendet wird.
Zeitstempel-Knoten
Domain bestimmt die Domne des Knotens, in diesem Fall "timestamp". Sample zeigt ein Beispiel, wie die Daten im Knoten formatiert sein wrden. (Schreibgeschtzt) Timestamp Sequence ist die Reihenfolge von Jahr, Monat, Tag, Stunde, Minute, Sekunde und Millisekunde, die in diesem Knoten verwendet wird. Es gibt zwei Optionen, eine mit Millisekunden und eine ohne.
Date Separator ist das Trennzeichen, das zwischen den Teilen eines Datums verwendet wird. Date-Time Separator ist das Trennzeichen, das zwischen dem Datum und der Uhrzeit verwendet wird. Time Separator ist das Trennzeichen, das zwischen den Teilen einer Uhrzeit verwendet wird. Millisec Separator ist das Trennzeichen, das zwischen der Uhrzeit und den Millisekunden verwendet wird. Time Zone zeigt an, ob in den XML-Daten eine Zeitzone enthalten sein wird. Die Zeitzonen-Daten werden gem W3C-Norm gendert. Die W3C-Norm erfordert ein "T" als Trennzeichen fr Datum/Uhrzeit und ein Standard-Zeitzonenformat. Das Zeitzonenformat kann entweder ein 5Zeichen-Offset von der Greenwich Mean Time sein (z.B. +05:00) oder eine Zulu-Zeit (GMT Bezeichnung von "Z"). Damit XML-Writer W3C-Zeitzonen untersttzen knnen, muss der IDS-Input 26 Zeichen lang sein; 20 fr den Standard-Zeitstempel (JJJJMMTThhmmssmmmmmm) und bis zu 6, um den GMT-Offset aufzunehmen (+05:00). XML-Reader verarbeiten Zeitstempel-Knoten hinsichtlich eines gltigen W3C-Zeitzonenformats. Ein ungltiges Zeitzonenformat lst einen Formatfehler im Reader aus.
Generierungs-Einstellungen
Variable Length
Das Lngenfeld wird verwendet, um die Lnge eines Feldes mit variabler Lnge zu beeinflussen. Wenn die Eigenschaft "Variable Length" fr einen Knoten auf "true" eingestellt ist, wird automatisch eine Lngenfeld fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Das Lngenfeld wird von einem XML-Reader zurckgegeben, um die Lnge des gelesenen Feldes anzuzeigen an einen XML-Writer weitergereicht, um anzuzeigen, wie viele Zeichen des Inhalts fr den Knoten ausgegeben werden sollen.
Optional Flag Field

Wenn die Eigenschaft "Optional Flag Field" fr einen Knoten auf "true" gesetzt ist, enthlt die generierte IDS ein zustzliches "flag field", das dem Knoten zugeordnet ist. Ein optionales Flag-Feld wird von einem XML-Reader zurckgegeben, um anzuzeigen, ob in der XML-Instanz ein Knoten gefunden wurde. Wenn der Wert des Flags auf 1 gesetzt ist, wurde der Knoten gefunden und der Inhalt des IDS-Feldes ist der im Dokument gefundene. Wenn der Wert des Flags 0 ist, wurde der Knoten nicht gefunden und der im IDS-Feld zurckgegebene Inhalt ist der Initialisierungs-Wert. an einen XML-Writer bergeben, um anzuzeigen, ob ein optionaler Knoten unterdrckt werden soll. Wenn der Wert des Flags auf 1 gesetzt ist, wird der Knoten ausgegeben. Wenn der des Flags auf 0 gesetzt ist, wird der Knoten nicht ausgegeben.
Track Pointers
Track Pointer werden verwendet, um die Anfangsposition des ffnenden Tags und die Endposition eines schlieenden Tags fr einen Knoten anzuzeigen. Wenn die Eigenschaft "Track Pointers" auf "true" gesetzt ist, werden 2 Felder (eines fr die Anfangsposition und eines fr das Ende) automatisch fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Track Pointer werden nur von XML-Readern verwendet. Der Reader gibt die Anfangs- und EndPosition des jeweiligen XML-Knotens wieder.
Extended Precision
Das Feld "Extended Precision" wird verwendet, um die dezimale Genauigkeit fr ein numerisches Feld festzulegen, das Dezimalstellen enthlt. Wenn die Eigenschaft auf "true" gesetzt ist, wird automatisch ein Feld mit erweiterter Genauigkeit in die IDS eingefgt und das ursprngliche Feld in
ein Feld fr Integer-Werte (ohne Dezimalstellen) konvertiert. Zum Beispiel wird ein Feld mit einer COBOL-Deklaration PIC 9(11)V9(2) in zwei Felder konvertiert: Eines mit einer Deklaration PIC 9(13), um alle Ziffern des Inhalts aufzunehmen (integer und dezimal) Eines mit einer Deklaration PIC S9(3), um aufzunehmen, wie viele Dezimalstellen der Wert enthlt (z.B. -3 zeigt an, dass es 3 Dezimalstellen gibt.
Das Feld Extended Precision wird von einem XML-Reader wiedergegeben, um anzuzeigen, wie viele Dezimalstellen im Dokument gefunden wurden.
IDS-Knoten-Eigenschaften
Wenn Sie in der Symbolleiste auf die Option IDS Properties klicken, wird auf der rechten Seite des Designer-Fensters ein Eigenschaften-Fensterausschnitt eingeblendet. Darin finden Sie die Informationen, die aus der IDS hinsichtlich des ausgewhlten IDS-Elementes abgeleitet wurden. Sie knnen die Eigenschaften anderer Knoten anzeigen, indem Sie auf einen anderen Knoten im IDSBaum klicken. Der Eigenschaften-Fensterausschnitt bleibt geffnet.
Field Domain ist der von der Programmiersprache abhngige Typ des Feldes. Field Name ist das Datenfeld fr den Strukturnamen. Field Occurs ist die Anzahl, die das Datenfeld oder die Struktur vorkommt. Field Size ist die Lnge des Datenfeldes
XML Thunder
Design bernehmen
bersicht
Die Funktion Adopt ermglicht es, das Design eines vorhandenen XML-Handlers in das aktuelle Design zu bernehmen. Klicken Sie auf XML-Handler Adopt , um diese Funktion aufzurufen. *Diese Funktion ist nur dann aktiviert, wenn von einer COBOL- oder C-Datenstruktur ausgegangen wird. Schritt 1: Whlen Sie einen vorhandenen XML-Handler aus dem aktuellen Ordner aus. Wenn Sie mchten, knnen Sie einen mit einer anderen Sprache auswhlen.
Schritt 2: Ordnen Sie die Ziel- und Quellelemente einander zu. In der Liste "Target" werden die zuzuordnenden aktuellen IDS-Elemente angezeigt. In der Liste "Source" werden die IDS-Elemente des Quell-XML-Handlers angezeigt.
82 Design bernehmen
XML Thunder
Mit der Schaltflche Match knnen die aktuell ausgewhlten Ziel- und Quellelemente einander zugeordnet werden, wenn sie kompatibel sind. Zwei Elemente sind kompatibel, wenn sie sich auf derselben Hierarchie-Ebene befinden und ihre bergeordneten Element auch einander zugeordnet sind (falls sie Teil einer geschachtelten Struktur sind). Die Kompatibilittsregeln knnen sich in zuknftigen Versionen in Abhngigkeit der fr die IDS-Elemente gespeicherten und verwendeten Informationen ndern. Die Schaltflche Unmatch lst die Zuordnung wieder auf, wenn zwei Elemente schon einander zugeordnet wurden. Mit der Schaltflche Find & Match kann fr das ausgewhlte Quell-Element ein passendes Ziel-Element auf Grundlage der hnlichkeit von Namen, der Domne, der Lnge und der Platzierung in der IDS-Hierarchie gefunden werden. Mit dem ersten Klick wird ein passendes Element gefunden, mit dem zweiten Klick wird die Zuordnung durchgefhrt. Mit der Schaltflche Auto Match wird die Funktion "find & match" fr die gesamte Liste von Elementen in der "Quell"-Liste automatisiert. Alle "Quell"-Elemente werden durchlaufen und fr jedes davon wird die Funktion "find & match" ausgefhrt. Wenn die zugeordneten Elemente nicht ganz gleich sind, wird am Ende des Vorgangs die Spalte Notes in der Liste target mit Hinweisen gefllt. Dabei handelt es sich meistens nur um Warnungen, aber die Hinweise mssen geprft werden, bevor die Zuordnung der Elemente akzeptiert wird. Manchmal knnen Elemente aufgrund der Zuordnungsoptionen falsch zugeordnet worden sein. In der Spalte "Notes" knnen folgende Hinweise stehen: Different position: Dies bedeutet, dass die zugeordneten Elemente an verschiedenen Positionen stehen. Das sollte nicht passieren, wenn Sie die Reihenfolge der Felder nicht gendert haben. Different attribute name: Dies bedeutet, dass die zugeordneten Elemente verschiedene Attributnamen haben (z.B. knnen die Enden der Elementnamen unterschiedlich sein). Das sollte nicht passieren, wenn Sie die Namen nicht gendert haben. Einstellen der Optionen fr "Find & Match" Klicken Sie auf Options, um folgendes Dialogfenster mit den Optionen zu ffnen, mit denen die Suche und Zuordnung beeinflusst werden kann.
XML Thunder
Design bernehmen 83
Best name: Die Elemente mit den einander hnlichsten Namen werden ausgewhlt. Verwenden Sie diese Option, wenn Sie zwei verschiedene XML-Handler bernehmen und diese hnliche, aber nicht genau gleiche Feldtypen haben. Exact name: Nur Elemente mit genau den gleichen Namen werden ausgewhlt. Verwenden Sie diese Option, wenn Felder aus demselben XML-Handler entfernt oder ihm hinzugefgt wurden und Sie die Versionen vergleichen mchten. Preferred position: Elemente mit der gleichen Position in der IDS-Feldreihenfolge werden bevorzugt. Verwenden Sie diese Option, wenn Namen aufgrund der Einschrnkungen von Programmiersprachen etwas verndert wurden, aber die Feldreihenfolgen nicht gendert wurden. Klicken Sie auf die Schaltflche OK, um bernahme-Dialogfenster zurckzukehren. Schritt 3: Klicken Sie auf OK Wenn auf OK geklickt wird, wird das "source"-Dokument in das "target"-Dokument bernommen, indem das XML-Design und die Daten-Abbildungen, die durch das Zuordnen erhalten wurden, kopiert werden. Beachten Sie, dass es sinnvoll sein kann, berhaupt keine Zuordnung vorzunehmen. In diesem Fall wird nur das XML-Design ohne die Daten-Abbildungen bernommen.
Lizenz-Management
Aktivieren einer Lizenz

Sie knnen das Fenster License Management ffnen, indem Sie die Men-Eintrag ToolsLicense management auswhlen.
84 Lizenz-Management
XML Thunder
Wenn Sie auf Ihrer Arbeitsstation eine Internetverbindung haben und Canam Software Ihnen eine LicenseID und ein Passwort mitgeteilt hat, knnen Sie die folgende Anleitung zur OnlineRegistrierung befolgen. Wenn Sie keine Internetverbindung oder keine LicenseID mit Passwort haben, knnen Sie die Anleitung zur Offline-Registrierung - Option A befolgen. Wenn Sie eine LicenseID und ein Passwort haben, aber die Internetverbindung an einer anderen Arbeitsstation verwenden mchten, knnen Sie die Anleitung fr Offline-Registrierung - Option B befolgen. Wenn die Registrierung (online oder offline) abgeschlossen ist, wird ein Fenster mit einer Besttigungsmeldung geffnet, in der mitgeteilt wird, dass Ihre Lizenz erfolgreich aktiviert wurde. Klicken Sie auf OK und fahren Sie fort. Falls eine Fehlermeldung angezeigt wird, wenden Sie sich bitte per E-Mail an support@canamsoftware.com und fgen Sie die Fehlermeldung sowie die vollstndigen Lizenzinformationen bei, die Sie aus dem Feld Current License Details oben im Fenster kopieren knnen.
Online-Registrierung
Wenn Sie an der Arbeitsstation eine Internetverbindung und die LicenseID mit Passwort von Canam Software haben, klicken Sie auf die Schaltflche Register Online.
Geben Sie die License ID und das Passwort ein. Wenn sich Ihr Computer hinter einem Proxyserver befindet, klicken Sie auf die Schaltflche "Proxy" und geben Sie die Proxy-Server-Adresse ein. Klicken Sie zum Registrieren auf OK.
Offline-Registrierung
Wenn die Arbeitsstation keine Internetverbindung hat, klicken Sie auf Register Offline.
XML Thunder
Lizenz-Management 85
Option A - Zugangsdaten per E-Mail vom Canam-Support anfordern. Senden Sie eine E-Mail an support@canamsoftware.com und fgen Sie die Lizenzinformationen bei, einschlielich User Code 1 (und 2), um die Registrierungscodes 1 (und 2) zu erhalten. Die SupportMitarbeiter senden Ihnen dann einen (oder zwei) Registrierungscodes per E-Mail oder Telefon. Gegen Sie Reg Key1 (und Reg Key 2) ein, wenn Sie diese per E-Mail erhalten haben. Option B - Online-Aktivierung unter Verwendung Ihrer LicenseID mit Passwort. ffnen Sie mit einem Internet-Browser (geht auch von einer anderen Arbeitsstation) folgende Adresse: http://secure.softwarekey.com/solo/unlock/ Auf der Startseite werden Sie aufgefordert, License ID und Password einzugeben, die Sie von Canam Software erhalten haben. Bitte geben Sie diese hier ein und klicken Sie auf Submit. Auf der nchsten Seite werden Sie aufgefordert, User Code 1 und 2 einzugeben. Bitte geben Sie diese ein und klicken Sie auf Submit. Die Website zur Software-Aktivierung gibt dann einen Registration Code 1 und (optional) einen Registration Code 2 zurck. Es ist wichtig, diese Zahlen zu speichern und das Fenster zu schlieen. Die Website zur Software-Aktivierung geht davon aus, dass Sie Ihre Lizenz aktiviert haben und zhlt die Anzahl der Lizenzen, die Ihrer Firma zugeteilt sind, um eins herunter. Wenn Sie dies ein zweites Mal fr denselben Computer durchfhren, wird die Anzahl ein zweites Mal heruntergezhlt. Geben Sie Reg Key1 (und Reg Key 2) im Fenster "Registration" ein und klicken Sie auf OK.
Lizenz-Ordner einstellen
Die Lizenzdatei von XML Thunder (tx2e.lic) befindet sich im Fall einer Arbeitsstations-Lizenz auf Ihrem Computer und im Fall einer simultanen Netzwerklizenz auf einem festen Server. Wenn Sie eine Arbeitsstations-Lizenz in eine Netzwerk-Lizenz oder umgekehrt konvertieren mchten, mssen Sie den Speicherort der Lizenzdatei fr XML Thunder angeben. Beachten Sie, dass pro Benutzer nur eine aktive Lizenzdatei zulssig ist. Wenn Sie den Speicherort der Lizenzdatei fr XML Thunder ndern mchten, mssen Sie auf Tools Set License Location klicken und dann zum Speicherort der neuen Lizenzdatei navigieren.
86 Lizenz-Management
XML Thunder
Software-Aktualisierung
Eine neue Funktion von XML Thunder ist die Mglichkeit fr den Benutzer, neue Versionen des Tools selbst zu installieren. Bitte wenden Sie sich zur Einrichtung dieser Funktion an Ihren Systemadministrator. Die Installations-Programme, die neue Versionen von XML Thunder installieren, werden in einem gesicherten Bereich auf einem Server Ihres Betriebes gespeichert.
Fortgeschrittene Themen
XML-Schema-Untersttzung
In der folgenden Tabelle sind die untersttzten XML-Schema-Komponenten aufgefhrt.
Schema-Element XML Thunderquivalent Attribut Schema-Attribut XML Thunderquivalent Name required=yes/no *nicht verwendet default value *nicht verwendet name maxOcc minOccurs, required=yes/no *nicht verwendet, Elemente knnen keinen gemischten Inhalt haben default value Nillable *nicht verwendet
Attribut
Element
element
Name use="required, optional use="prohibited" default field, form, id name maxOccurs minOccurs mixed
default nillable abstract, block, final, form, id substitutionGroup Group all, sequence, choice, simpleContent, simpleType, complexContent, complexType Documentation, annotation extension, restriction *zu Elementen konvertiert *zu Elementen konvertiert
processed as group
*converted to comments *zum berschreiben von Eigenschaften verwendet *in aktuelles Schema geladen und verarbeitet
Include
XML Thunder
Fortgeschrittene Themen 87
field, key, appInfo, attributeGroup, import, key, keyref, list, redefine, selector, union, unique, any, anyAttribute Datentyp-Facetten totalDigits fractionDigits length minLength maxLength Enumeration Pattern whiteSpace maxInclusive maxEclusive, minExclusive, minInclusive Datentypen String dateTime Time Date gYearMonth gYear gMonth gDay gMonthDay Decimal Float Double Long unsignedLong Integer positiveInteger nonPositiveInteger negativeInteger nonNegativeInteger Int unsignedInt Short unsignedShort Byte unsignedByte normalizedString, token, language, IDREFS, ENTITIES, NMTOKEN, NMTOKENS, Name, NCName, ID, IDREF, ENTITY, Boolean, hexBinary, base64Binary, QName, NOTATION, anyURI, duration
*nicht verwendet
number(n) number(?, n) text(n) text(n) variable text(n) variable Enumeration *nicht verwendet whiteSpace determines length *nicht verwendet
Text date ('yyyy-MMddTHH:mm:ss.SSS') date('HH:mm:ss') date('yyyy-MM-dd') date('yyyy-MM') date('yyyy') date('MM') date('dd') date('MM-dd') number(18) number(18) number(18) number(18) number(18) number(10) number(10) number(10) number(10) number(10) number(10) number(10) number(5) number(5) number(3) number(3) *defaults to text
Namensrume
XML Thunder bietet eine vollstndige Untersttzung von Namensrumen fr COBOL-Reader und Writer. Namensrume fr C werden zurzeit nicht untersttzt, jedoch kann ein XML-Reader fr C88 Fortgeschrittene Themen XML Thunder
Code so eingerichtet werden, dass er Namensraum-Prfixe ignoriert. In diesem Fall kann ein XMLDokument dadurch eingelesen werden, dass der XML-Reader fr C die Namensraum-Prfixe ignoriert. Namensrume werden nur von Handlern untersttzt, die unter Verwendung eines Schemas, einer DTD, einer WSDL oder eines Beispiel-Dokuments erstellt wurden. Die Namensraum-Deklarationen werden aus diesen Quellen in das Handler-Design importiert.
XML Choice
Ein Choice-Element im XML-Schema stellt sicher, dass nur eines der in der <choice>-Deklaration enthaltenen Elemente in der jeweiligen XML-Instanz enthalten sein kann. Betrachten Sie folgendes Schema:
Im obigen Schema enthlt das Element "Address" eine <choice>-Konstruktion, die festlegt, dass eine XML-Instanz nur eines der Elemente "CAN-Address", "US-Address" oder "OtherCountry" enthalten kann. Die drei Elemente schlieen sich gegenseitig aus - was bedeutet, dass in einer beliebigen XMLInstanz nur eines der drei vorhanden sein kann. XML Thunder bietet eine vollstndige Untersttzung fr das XML-Choice-Konstrukt, indem es die vollstndige, im XML-Schema deklarierte Choice-Struktur repliziert und ein spezielles, SelectionAttribut genanntes Feld hinzufgt. Im folgenden Beispiel wurden alle drei Auswahlmglichkeiten im Handler-Design definiert und ein Selection-Attribut hinzugefgt. Jedes auftretende "Address" kann ein Element "CAN-Address", "US-Address" oder "OtherCountry" enthalten.
Das Attribut "Selection" wird wie jeder andere Knoten auf ein IDS-Feld abgebildet.
XML Thunder
Choice-Attribut "Selection" Das Choice-Attribut "Selection" ist ein Spezialfeld von XML Thunder, das zur Kontrolle von XMLChoice-Strukturen verwendet wird. Wie alle Spezialfelder erscheint das Attribut "Selection" nicht in der eigentlichen, von einem Writer erstellten XML-Instanz, noch wird es von einem XML-Reader gesucht. Per Voreinstellung ist der Name dieses Feldes "Selection" und seine Lnge ist 100. Diese Einstellungen knnen vom Benutzer an folgender Stelle im Men gendert werden: Tools -> Default Properties -> XML Rules -> XSD Indicators.
Das Attribut "Selection" wird auf ein IDS-Feld abgebildet und folgenderweise vom aufrufenden Programm verwendet: Fr Reader: Das Attribut "Selection" wird vom XML-Reader-Handler mit dem Choice-Zweig gefllt, der beim Lesen des XML-Dokuments gefunden wurde. Das aufrufende Programm kann das Attribut "Selection" verwenden, um zu bestimmen, welche Auswahl gefunden wurde. Fr Writer: Das Attribut "Selection" wird verwendet, um dem XML-Writer-Handler mitzuteilen, welcher ChoiceZweig ausgegeben werden soll. Es wird vom aufrufenden Programm gefllt und dem XML-Writer bergeben.
90 Fortgeschrittene Themen XML Thunder
Choice - Selection attribute value: Der Wert des Feldes "Selection attribute value" bestimmt, welcher Choice-Zweig erstellt werden soll (Writer) oder welcher Choice-Zweig gelesen wurde (Reader). Sie haben zwei Mglichkeiten, den "Selection attribute value" einzustellen:
XML Node Name: Das Attribut "Selection" erhlt den Namen des XML-Knotens, der einen der Choice-Knoten umfasst. Diese Einstellung knnen Sie nur verwenden, wenn die Knotennamen der Auswahl im HandlerDesign eindeutig definiert sind.
Beispiel: CAN-Address
Qualified XML Node Name - das Attribut "Selection" erhlt den vollstndigen Namen (einschlielich Kontext) des XML-Knotens, der einen der Choice-Knoten umfasst. Wenn der qualifizierte XMLKnotenname verwendet wird, bedeutet das, dass der Wert des Attributs "Selection" lnger wird, aber eindeutig.
Beispiel: Contact.Customer.Address.XT-XML-CHOICE-0003.CAN-Address
Die einfachste Weise, die mglichen Werte des XML-Struktur-Attributs zu bestimmen, besteht darin, den Writer Test Harness fr das Handler-Design zu generieren. Er enthlt alle mglichen Werte des Attributs "Selection" als Kommentare im Absatz BUSINESS-LOGIC-BEFORE.
Hinweis: Der Wert des Attributs "Selection" enthlt keine <sequence>- oder <all>-Knoten, auer wenn sie einer <choice> direkt untergeordnet sind. Das heit, dass sie nicht eingeschlossen werden, auer wenn sie tatschliche Auswahlmglichkeiten sind. Betrachten Sie das folgende Beispiel:
Die Auswahl XT-XML-CHOICE-01 hat drei Auswahlmglichkeiten - E2, XT-XML-SEQUENCE-01 und XT-XML-CHOICE-02. Die Werte des Attributs "Selection" fr diese Auswahlmglichkeiten lauten bei Verwendung von "Qualified XML Node Name": E1.XT-XML-CHOICE-01.E2 E1.XT-XML-CHOICE-01.XT-XML-SEQUENCE-01 E1.XT-XML-CHOICE-01.XT-XML-CHOICE-02
Choice - Structure Physical IDS:

XML Thunder Fortgeschrittene Themen 91
Die physische IDS zur Untersttzung der Auswahlfunktion enthlt Programmfelder fr alle Auswahlmglichkeiten. Im folgenden Beispiel wurden Strukturen zur Aufnahme aller drei mglichen Adresstypen definiert. Auch ein Choice-Attribut "Selection" wurde definiert.
Implementierung der Auswahlfunktion in Ihr aufrufendes Programm Die von XML Thunder generierten Test Harnesse enthalten Beispiele dafr, wie eine Auswahl verarbeitet wird. Fr Reader: Der XML-Handler parst die gefundenen XML-Knoten in die entsprechenden Programm-Datenfelder und fllt das Attribut "Selection" mit dem Wert der vorgefundenen Auswahl. Fr Writer: Das aufrufende Programm fllt die Programm-Datenfelder in die entsprechende Choice-Struktur, einschlielich des Werts des Attributs "Selection". Der XML-Writer verwendet den Wert des Attributs "Selection", um die auszugebende Choice-Struktur zu bestimmen.
XML Writer Mainline: MOVE Ontario TO XT-PROVINCE. MOVE L5R 3R3 TO XT-POSTAL-CODE. MOVE Contact.Customer.Address.XT-XML-CHOICE-0003.CAN-Address TO XT-SELECTION.
XML-Ausgabe:
XML Sequence
XML Sequence ist eines der am hufigsten vorkommenden und verwendeten Teile in einem XMLSchema. Es dient als Verbindung zwischen berund untergeordneten Elementen sowie zum Festlegen einer bestimmten Ordnung, in der seine Elemente in einem XML-Dokument vorgefunden
werden sollen. Die untergeordneten Elemente eines <sequence>-Knotens mssen im XMLDokument in der Reihenfolge auftreten, in der sie aufgelistet sind.
XML-Reader erzwingen <sequence>, indem sie beim Lesen eines XML-Dokuments die Reihenfolge der Folgen-Elemente prfen. Ein "out of sequence"-Fehler wird gemeldet, wenn ein Knoten nicht richtig eingeordnet ist.
XML-Writer geben die Folgen-Elemente in derselben Reihenfolge aus, in der sie im XML-HandlerDesign definiert wurden.
Die einzige Einschrnkung fr ein <sequence>-Konstrukt besteht darin, dass es <all> nicht als direkt untergeordnetes Element enthalten kann.
<sequence> <all>
Per Voreinstellung wird im XML Thunder-Designer fr den <sequence>-Knoten der Name "XTXML-SEQUENCE-nnnn" verwendet, wobei "nnnn" eine Aufzhlungsnummer ist. Dies kann vom Benutzer unter dem Menpunkt "Tool > Options > XML Facets > XML Sequence > Default sequence node name" angepasst werden.
XML Thunder
XML All
Die XML-ALL-Struktur hnelt insofern der XML Sequence, dass es als Verbindung zwischen berund untergeordneten Elementen dient. Es unterscheidet sich von Sequence aber insofern, dass die untergeordneten Elemente in einer beliebigen Reihenfolge in einem beliebigen Dokument stehen knnen.
Ein XML Thunder-Reader erlaubt untergeordnete Elemente unter einem <all>-Konstrukt in jeder Reihenfolge (d.h. es wird kein "out of sequence"-Fehler gemeldet). Ein XML Thunder-Writer gibt die einem <all>-Konstrukt untergeordneten Elemente immer in der Reihenfolge aus, in der sie in der Handler-Definition stehen. Das ist fr <all> nicht unbedingt erforderlich, wird aber von XML Thunder-Writern so durchgefhrt. Ein <all>-Konstrukt kann als direkt untergeordnete Elemente nur nicht-wiederholte Elemente enthalten. Dementsprechend kann es keinen <sequence>- oder <choice>-Knoten als direkt bergeordnetes Element haben.
Zulssig a) <all> <element-1 maxOccurs = 1> <element-1 maxOccurs = 1> <all>
b)
Unzulssig a) <all> <sequence>
b) <all> <choice>
c) <all> <all>
d) <all>
<element-1 maxOccurs = 2> (d.h. ein wiederholtes Element) <element-1 maxOccurs = 2> (d.h. ein wiederholtes Element) <all> Per Voreinstellung ist dieser Name "XT-XML-ALL-nnnn", wobei "nnnn" eine Reihenfolgennummer ist. Dies kann vom Benutzer unter dem Menpunkt "Tool > Options > XML Facets > XML Sequence > Default sequence node name" angepasst werden.
e)
XML-BUFFER
Ein XML-Handler ist darauf ausgelegt, ein Puffer-Feld mit einer fortlaufenden Zeichenkette zu verarbeiten. Die Struktur des Zeichenketten-Puffers wird automatisch der IDS (Interface Data Structure) des generierten Codes hinzugefgt. Sie kann auch per Voreinstellung im Quell-Copybook bereitgestellt werden. Wenn der im Copybook definierte Puffer verwendet werden soll, sollte er folgende Namen und Struktur erhalten: COBOL 01 CANAM-XML-BUFFER. 03 XML-BUFFER-STRUCT. 05 XML-BUFFER-LENGTH PIC S9(9) COMP. 05 XML-BUFFER PIC X(nnnnn). C struct canam_xml_buffer { struct { char xml_buffer[n+1]; } xml_buffer_struct; };
Sie mssen fr die Lnge des Feldes XML-BUFFER einen geeigneten Wert eingeben. Dieser muss gro genug fr die Bearbeitung eines einzelnen XML-Dokuments sein, das Sie entwerfen mchten. Sie knnen die Mindestlnge des Feldes spter ber XML Handler->Properties einstellen. Wenn der ursprngliche Wert des Feldes weniger als das angegebene Minimum ist, wird er auf den angegebenen Wert gesetzt. Die XML-Pufferstruktur und das Feld werden nicht im Fensterabschnitt IDS gezeigt, da sie keine Bestandteile des entworfenen Dokuments sind. Stattdessen werden sie im Fensterausschnitt "Summary" angezeigt, wenn sie im eingelesenen Copybook enthalten sind.
Festlegen der XML-Puffer-Gre

Die maximale XML-Puffer-Gre muss fr alle XML-Handler festgelegt werden. Sie knnen den Wert im Fenster XML handler->Properties->General eingeben. XML Thunder berechnet Minimum- und Maximum-Schtzwerte fr das aktuelle Dokument-Design und der Code-Generator verwendet den Maximal-Wert wenn der Wert nicht ausdrcklich angegeben wird.
Numerische Zeichenverweise
Zeichen im Bereich von 0x80 bis 0xFF knnen als numerische Zeichen-Entitten dargestellt werden. Der XML-Writer kann automatisch quivalente Zeichenverweise generieren. Dementsprechend kann der XML-Reader alle Zeichenverweis-Werte im Bereich bis ÿ lesen, wobei er sie in ihre entsprechenden Byte-Werte konvertiert. Diese Option kann fr jeden XML-Handler getrennt eingestellt werden.
XML Thunder
Gemischte Inhalte
Gemischte Inhalte, die beim Parsen gefunden werden, werden ohne Warnmeldung ignoriert. Gemischte Inhalte werden im Allgemeinen in HTML-hnlichen XML-Dateien (wie .xhtml) verwendet, um Formatierungen zu markieren, und wird zurzeit nicht untersttzt. Im Allgemeinen ist es fr die Verbindung zweier Systeme kein "gutes" Design, in einer XMLStruktur gemischte Inhalte zu definieren. Zum Beispiel: ....<name>Julius<middle>Henry</middle>Marx</name>.... Das obige XML hat gemischte Inhalte innerhalb des Elements <name>, eine einzelne Textinformation, die durch Markierungen in drei Teile getrennt wird. In diesem Fall sind "Julius" und "Marx" Teile desselben gemischten Inhalts. Dadurch wird praktisch die Konsistenz des <name>Elements zerstrt, was gegen das Ziel von XML verstt, die Bedeutung der Daten mglichst klar zu machen. Eine Alternative ohne gemischte Inhalte ist: ...<name><first>Julius</first><middle>Henry</middle><last>Marx</last></name>... In diesem Fall werden die Textdaten wie erforderlich getrennt und durch ihr eigenes Tag gekennzeichnet.
Validierung
Wenn Sie ein Handler-Design unter Verwendung eines XML-Schemas erstellen, wendet der generierte Handler-Code die definierten Regeln an. XML-Schema-Facetten wie "min/maxOccurs", "min/maxLength", und "required" sind nur einige der in Kraft gesetzten Einschrnkungen. Darber hinaus knnen Sie bestimmte Validierungsregeln fr die Struktur des XML-Dokuments und das Format der Daten angeben. Whrend der Ausfhrung verifiziert der XML-Handler diese Regeln. Zum Beispiel knnen Sie festlegen, ob ein Knoten "optional" ist oder nicht. Wenn der Reader erkennt, dass ein obligatorischer Knoten fehlt, lst er einen Ausnahmefehler aus und beendet die Verarbeitung. Andere Beispiele sind die Verarbeitung zustzlicher Inhalte oder unbekannter oder fremder Knoten. Sie knnen festlegen, ob ein Knoten "extensible" (erweiterbar) ist, Wenn der Reader auf einen undefinierten Knoten trifft, bzw. einen zustzlichen oder unbekannten Inhalt innerhalb eines Elements, gibt er einen Fehlercode zurck, wenn der Knoten nicht erweiterbar ist - andernfalls berspringt er den unbekannten Inhalt ohne Warnmeldung. Auerdem werden die von XML Thunder untersttzten XML-Facetten durchgesetzt, whrend die Validitt der XML-Dokumente geprft wird.
Element oder Attribut

Bei der teilweisen oder kompletten Umformung einer IDS in eine XML-Struktur knnen Sie entscheiden, ob ein Datenfeld zu einem XML-Element oder XML-Attribut wird, indem Sie die Tools "Transform as ELEMENT" oder "Transform as ATTRIBUTE" auswhlen. Dies geht nur, wenn mindestens ein IDS-Feld zur Umwandlung ausgewhlt ist. Wenn Sie mindestens eine Struktur und mehrere Felder auf der IDS-Seite auswhlen, wird nur aktiviert. In diesem Fall verwendet das Tool eine Standardeinstellung, um zu entscheiden, ob fr untergeordnete Felder ein Element oder ein Attribut erstellt wird. Diese Einstellung kann im Men "Tools->Options->Editor" angepasst werden.. Aktivieren Sie das Kontrollkstchen um alle untergeordneten Elemente per Voreinstellung in XML-Attribute umzuwandeln, oder deaktivieren Sie es, um sie zu XML-Elementen zu machen. Dieselbe Voreinstellung kommt zur Anwendung, wenn Sie den XML-Handler mit dem Assistenten erstellen und auswhlen, dass das XML-Design automatisch auf Grundlage der IDS erstellt wird. Der
Assistent erstellt per Voreinstellung XML-Elemente fr die Elemente einer Struktur-Ebene und erstellt Elemente oder Attribute je nach Einstellung der Umwandlungsart.
Wiederholte Strukturen
XML-Dokumente enthalten oft wiederholte Strukturen. In vielen Fllen ist die Obergrenze der wiederholten Struktur durch die Eigenschaft maxOccurs definiert (befindet sich im Schema oder wird im XML Thunder-Designer eingestellt).
Abbilden wiederholter Strukturen

Damit die einer wiederholten Struktur zugrunde liegenden IDS-Felder abgebildet werden knnen, mssen Sie zuerst die bergeordnete wiederholte Struktur auf das bergeordnete XML-Element abbilden. Das Tool erlaubt Ihnen nicht, ein IDS-Feld abzubilden, wenn sein bergeordnetes Element eine wiederholte Struktur ist, die noch nicht abgebildet ist. Dieselbe Einschrnkung gilt fr verschachtelte wiederholte Strukturen. Die bergeordneten wiederholten Strukturen mssen aufeinander abgebildet werden, bevor ihnen untergeordnete Strukturen abgebildet werden knnen. Daraus folgt, dass die Verschachtelungsstruktur der abgebildeten XML-Elemente die gleiche ist wie auf der IDS-Seite.
Zhler-Spezialfelder
Fr jede wiederholte Struktur wird ein spezielles numerisches Zhlerfeld auf der IDS-Seite bentigt. Mit dem Zhlerfeld wird gesteuert, wie viele Male der XML-Writer etwas ausgibt. Bei einem XMLReader enthlt der Zhler die Anzahl, wie oft etwas im gelesenen Dokument vorgekommen ist.
Wenn das XML-Design auf einem XML-Schema oder einer XML-Instanz beruht, ist kein Abbildungsvorgang erforderlich und die zugrunde liegenden wiederholten IDS mit Zhlerfeldern werden automatisch fr Sie erstellt.
Optionale Elemente und Attribute

Optionale XML-Elemente und -Attribute knnen mit den entsprechenden "Flag"-Feldern in der IDS gesteuert werden. Bei einem XML-Handler, der auf ein XML-Schema oder Beispiel gesttzt ist, wird das "flag"-Feld automatisch fr alle optionalen XML-Elemente und -Attribute generiert. Beispielsweise fr eine XML-Schema-Definition wie diese: <xs:nodeA use=optional> in der entsprechenden IDS steht dann: 05 nodeA-flag PIC S9(1) COMP. 05 nodeA. 07 Bei einem XML-Handler, der auf eine IDS gesttzt ist, ist das "flag"-Feld fr ein optionales Element einem "counter"-Feld hnlich. Es muss ein numerisches Feld sein, es muss ausdrcklich im Copybook definiert sein und dann muss es mit dem Mapping-Tool "Map Count" auf das zugehrige optionale XML-Element oder -Attribut abgebildet werden, Dadurch entsteht eine Verknpfung zwischen dem abgebildeten XML-Element und dem numerischen "flag"-Feld (wird als "*"-Knoten im Bearbeitungsfenster angezeigt). Wie bei einem "counter"-Feld wird das "flag"-Feld dann auf 0 gesetzt, um kein Tag zu erzeugen, andernfalls auf 1. Dementsprechend setzt der XML-Reader das entsprechende "flag"-Feld je nachdem, ob das XMLElement oder -Attribut vorhanden ist. Wenn XML-Elemente im Dokument vorhanden sind, hat das "flag"-Feld den Wert "1", sonst "0".
XML Thunder
Untersttzung von COBOL Redefines

Beim Importieren eines COBOL-Copybooks kann XML Thunder automatisch eine <choice>-Struktur aus einer Menge von COBOL-Redefines ableiten. Dies wird in folgenden Menpunkt festgelegt: Tools -> Default Properties -> IDS Rule -> Translate COBOL Redefines to XML Choice.
Wenn diese Einstellung verwendet wird, erstellt das folgende COBOL-Copybook: 01 XT-DATETIME PIC X(14). 01 XT-PRE-DATETIME REDEFINES XT-DATETIME. 03 XT-YEAR PIC X(4). 03 XT-MONTH PIC X(2). 03 XT-DAY PIC X(2). 03 XT-HOUR PIC X(2). 03 XT-MINUTE PIC X(2). 03 XT-SECOND PIC X(2). 01 XT-PRE-DATE REDEFINES XT-DATETIME. 03 XT-DATE PIC X(8). 03 FILLER PIC X(6). 01 XT-PRE-TIME REDEFINES XT-DATETIME. 03 FILLER PIC X(8). 03 XT-TIME PIC X(6). 01 XT-CHOICE-SEL PIC X(100).
den folgenden XML-Handler:
98 Fortgeschrittene Themen
XML Thunder
Untersttzung des Befehls XML PARSE

Fr COBOL-XML-Reader ist es mglich, die Verwendung des Befehls "XML PARSE" fr IBM Enterprise COBOL anstelle der eigenen XML-Parsingfunktion festzulegen. Es kann auf Systemebene eingestellt werden, oder auch auf individueller XML-Handler-Ebene. Wenn diese Option eingestellt ist, gibt der COBOL-XML-Reader "XML PARSE"-Befehle aus, um den Inhalt des XML-Puffers zu parsen und den restlichen Verarbeitungsvorgang auszufhren, wobei die Werte in ProgrammDatenbereiche kopiert werden und erforderliche Validierungen durchgefhrt werden. Je nachdem, wie Ihre Entwicklungsumgebung eingerichtet ist, muss der Programm-Quellcode fr diese Funktion auf spezielle Weise kompiliert oder auch aufbereitet werden. Weitere Informationen finden Sie im IBM Enterprise COBOL Programming Guide. Fr den Compiler Microfocus NetExpress lautet die Compiler-Direktive zur Aufbereitung wie folgt: $set p(prexml) warn endp $set DIALECT"MF"
*Der Befehl "XML PARSE" wird nur fr Handler auf Dokument-Ebene untersttzt. Handler auf Knoten-Ebene mssen das eigene XML-Parsing von XML Thunder verwenden.
Handler auf Dokument- und Knoten-Ebene

XML Thunder kann zwei verschiedene Handler-Typen zur Verarbeitung von XML-Instanzen generieren; fr die Dokument-Ebene oder die Knoten-Ebene. Ein Handler auf Dokument-Ebene verarbeitet die gesamte XML-Instanz mit nur einem Aufruf. Das aufrufende Programm sammelt alle erforderlichen Daten, ruft den XML-Handler auf und erhlt das Ergebnis zurck. Ein Handler auf Knoten-Ebene dagegen verwendet mehrere Aufrufe, um eine XMLInstanz zu verarbeiten. Bei jedem Aufruf wird ein Teil des XML-Textes verarbeitet und der Handler wird fortlaufend aufgerufen, bis die gesamte Instanz verarbeitet wurde. Wenn ein Handler-Design sowohl die Verarbeitung auf Dokument-Ebene als auch die auf KnotenEbene untersttzten soll, brauchen dazu keine Vernderungen an ihm vorgenommen zu werden. Das gleiche Handler-Design kann auf beide Weisen generiert werden. Der Handler-Typ wird durch eine Einstellung fr die Code-Generierung bestimmt.
XML Thunder
*XML-Handler auf Knoten-Ebene sind unter XML Thunder nicht fr PARSE verfgbar.
Handler auf Dokument-Ebene

Ein Handler auf Dokument-Ebene ist der einfachste Ansatz, weil nur ein Aufruf des XML-Handlers erforderlich ist. Ein Handler auf Knoten-Ebene wird blicherweise dann verwendet, wenn das zu verarbeitende XML-Dokument uerst umfangreich ist oder wenn die Obergrenze fr eine wiederholte Struktur unbekannt oder sehr hoch ist. In beiden Fllen knnen die zur Bearbeitung eines kompletten XML-Dokuments erklrten Variablen auf manchen Plattformen die Grenzen der Compiler berschreiten. Bei einem Handler auf Knoten-Ebene brauchen die Variablen nur gro genug zu sein, um das XML-Dokument Stck fr Stck zu verarbeiten. Ein Handler auf Dokument-Ebene hat folgende Merkmale: Der Handler wird vom aufrufenden Programm nur einmal aufgerufen. Der Handler verarbeitet die gesamte XML-Instanz mit nur einem Aufruf. Die Variable XML-BUFFER muss gro genug deklariert werden, um die gesamte XMLInstanz aufnehmen zu knnen. Die Programm-Datenfelder mssen gro genug deklariert werden, um die grte mgliche Anzahl vorkommender wiederholter Strukturen bearbeiten zu knnen. Sogar fr die als unbegrenzt definierten Strukturen in einem XML-Schema muss eine maximale Anzahl eingerichtet werden.
Hier ist ein Beispiel einer COBOL-IDS fr einen Handler auf Dokument-Ebene. Fr jede wiederholte Struktur ist eine OCCURS-Klausel definiert, die gro genug ist, alle mglichen Vorkommen eines Kunden aufzunehmen. Der Wert fr die OCCURS-Klausel ist durch die Einstellung von "maxOccurs" fr den XML-Knoten im Handler-Design bestimmt.
XML Thunder
Handler auf Knoten-Ebene

Ein Handler auf Knoten-Ebene hat folgende Merkmale: Der Handler wird vom aufrufenden Programm mehrmals aufgerufen. Bei jedem Aufruf werden nicht-wiederholte Daten oder auch eine Iteration einer wiederholten Struktur verarbeitet. Die Variable XML-BUFFER muss gro genug deklariert werden, um die Daten fr einen Aufruf des Handlers aufnehmen zu knnen. Die Variable XML-BUFFER wird fr jeden Aufruf wiederverwendet. Die Programm-Datenfelder enthalten keine OCCURS-Klauseln. Eine vereinfachte Datenstruktur wird verwendet und wiederholte Strukturen werden mit nur einer Iteration auf einmal verarbeitet.
Hier ist ein Beispiel einer COBOL-IDS fr einen Handler auf Knoten-Ebene. In diesem Fall gibt es keine OCCURS-Klausel fr wiederholte Strukturen (CUSTOMER und ADDRESS). Auerdem braucht die Variable XML-BUFFER nicht so gro zu sein, dass sie das ganze XML-Dokument aufnehmen kann.
XML Thunder
Ein Handler auf Knoten-Ebene hat folgende Vorteile: Es gibt keine Beschrnkung fr die Gre des zu verarbeitenden XML-Dokuments. Der zu einem bestimmten Zeitpunkt fr die Verarbeitung eines XML-Dokuments belegte Speicherplatz bleibt kontrollierbar. Die Puffergre kann an die Einschrnkungen lterer Compiler, in denen die deklarierbaren Felder enger beschrnkt sind, angepasst werden.
Handler auf Knoten-Ebene generieren per Definition eine IDS ohne Verwendung einer "occurs"Klausel (in COBOL) oder eines Arrays (in C) fr wiederholte Datenstrukturen. Stattdessen verwendet der Handler eine Einermenge als Datenfeldstruktur. Bei einem Writer werden die Datenfelder der Reihe nach an den Handler ausgegeben, whrend sie bei einem Reader der Reihe nach zurckerhalten werden. Dadurch kann der Handler eine unbegrenzte Zahl wiederholter Elemente lesen oder schreiben. Ein Handler auf Knoten-Ebene ist aber dennoch durch die Gre des XML-Puffers eingeschrnkt. Das gelesene oder geschriebene XML-Dokument kann nie grer sein als der fr das XML-Pufferfeld reservierte Speicherplatz. Durch die Generierung eines Handlers, der eine Verarbeitung auf Knoten-Ebene durchfhrt, entfllt diese Einschrnkung. Das fr einen Handler auf Knoten-Ebene generierte Feld CANAM-XML-BUFFER wird unten gezeigt. In diesem Beispiel kann das Feld XML-BUFFER bis zu 5000 Zeichen eines XMLDokuments auf einmal aufnehmen. Die Felder XML-BUFFER-LENGTH, XML-BPTR-BUFFER und XML-INTERNAL-STATES werden vom Handler intern verwendet und sollten nie verndert werden. Das Feld XML-MORE-BUFFER enthlt den aktuellen Stand der Bearbeitung fr das XMLDokument. Es gibt drei mgliche Werte: F - First, R - Repeating und L - Last.
XML-MORE-BUFFER
Mit der Einstellung fr Knoten-Ebene knnen Sie sowohl XML-Reader als auch -Writer generieren. Betrachten Sie das folgende Beispiel eines XML Thunder-Handlers mit einer komplexen Elementgruppe, die eine wiederholte Struktur mit dem Namen "Account" enthlt.
Beispiel-Handler Interface Data Structure (IDS): Bei Handlern auf Knoten-Ebene wird keine "occurs"-Klausel verwendet, um die wiederholte Struktur "Account" zu untersttzen. Stattdessen wird der Handler wiederholt fr jedes Element aufgerufen.
Beispiel-IDS fr Handler auf Knoten-Ebene
XML-Writer auf Knoten-Ebene

Ein XML-Writer auf Knoten-Ebene wird vom aufrufenden Programm mehrere Male aufgerufen und bei jedem Aufruf wird ein Teil des XML-Dokuments erstellt. Der von XML Thunder generierte Test Harness enthlt Beispiele dafr, wie ein XML-Writer auf Knoten-Ebene aufgerufen werden sollte. Zum Aufrufen des Handlers sollte das Hauptprogramm im Allgemeinen folgende Schritte durchfhren: Schritt 1: XML-MORE-BUFFER initialisieren Das Feld XML-MORE-BUFFER zeigt an, ob weitere in den Puffer zu schreibende Daten vorhanden sind. Bevor der Writer das erste Mal aufgerufen wird, sollte dieses Feld auf "F" (First-time) gesetzt werden.
Initialisieren des Feldes XML-MORE-BUFFER Schritt 2: IDS-Felder fllen Im Gegensatz zu Handlern auf Dokument-Ebene werden Handler auf Knoten-Ebene mehrmals aufgerufen. Wenn der Handler das erste Mal aufgerufen wird, werden alle Daten bis zum ersten Auftreten eines wiederholten Elements auf niedrigster Ebene geschrieben. Bei anschlieenden
XML Thunder Fortgeschrittene Themen 103
Aufrufen des Handlers sollte das nchste Element der wiederholten Struktur auf niedrigster Ebene bergeben werden, bis alle verarbeitet wurden. Nachdem alle Daten fr eine wiederholte Struktur an den Handler bergeben wurden, sollten alle Daten bis hin zur niedrigsten Ebene des nchsten wiederholten Elements bergeben werden. Zur Untersttzung der Verarbeitung wird fr jede wiederholte Struktur ein Zhlerfeld definiert. Obgleich Sie das Zhlerfeld nutzen knnen, um zu verfolgen, wie viele weitere Elemente noch ausgegeben werden mssen, prft der Handler eigentlich nur, ob der Wert grer als 0 ist. Wenn der Zhler fr eine wiederholte Struktur grer als Null ist, wird ein weiteres Element in das XMLDokument geschrieben. Wenn der Zhler auf Null gesetzt wird, wird dem Handler damit mitgeteilt, dass keine weiteren Elemente auszugeben sind. Im folgenden Beispiel wird der Zhler bei jedem iterativen Aufruf des Befehls PERFORM um 1 verringert, um Beispieldaten zu generieren. Das gleiche Ergebnis kann dadurch erreicht werden, den Zhler auf 1 zu halten, whrend Elemente der wiederholten Struktur geschrieben werden, und ihn dann auf 0 zu setzen, wenn keine weiteren Eintrge mehr zu schreiben sind.
Beispiel-Testprogramm zum Fllen der IDS Schritt 3: Handler aufrufen Sie knnen den XML-Handler wiederholt aufrufen und das XML-Dokument segmentweise im Feld XML-BUFFER zurckerhalten. Das Feld XML-RETURN-CODE ist auf MD ("More Data) gesetzt, wenn weitere zu schreibende Daten vorhanden sind, oder auf "OK", wenn alle Daten in den Puffer geschrieben wurden.
Aufrufen des XML-Writers
Schritt 4: Den Puffer lschen Wenn auf Knoten-Ebene generiert wird, wird das Feld XML-BUFFER bei jedem Aufruf des Handlers wiederverwendet. Aus diesem Grund muss der Puffer nach jedem Aufruf in einen anderen Speicherbereich verschoben werden (Datei, Datenbank, etc.), um Datenverlust zu vermeiden. Im Beispiel des Testprogramms wird der Puffer nach jedem Handler-Aufruf einfach auf der Konsole ausgegeben. Im Feld XML-BPTR-BUFFER steht, wie viele Zeichen vom Handler in das Feld XML104 Fortgeschrittene Themen XML Thunder
BUFFER geschrieben wurden. Wenn zum Beispiel das Feld XML-BUFFER mit einer Lnge von 5000 Zeichen definiert wurde und im Feld XML-BPTR-BUFFER die Zahl 700 steht, dann sollten nur die ersten 700 Zeichen aus XML-BUFFER verwendet werden.
Lschen des Puffers Wenn das XML-Dokument vollstndig in den Puffer geschrieben wurde, wird der XML-MOREBUFFER auf "L" gesetzt und XML-RETURN-CODE auf "OK".
XML-Reader auf Knoten-Ebene

Mit einem XML-Reader auf Knoten-Ebene knnen Sie ein groes XML-Dokument segmentweise einlesen. Dies erfolgt durch den wiederholten Aufruf eines Handlers, dem dabei Teile eines XMLDokuments bergeben werden, und durch die Rckgabe der entsprechenden Datenfelder nach jedem Aufruf. Der von XML Thunder generierte Test Harness enthlt Beispiele dafr, wie ein XML-Reader auf Knoten-Ebene aufgerufen werden sollte. Zum Aufrufen des Handlers sollte das Hauptprogramm im Allgemeinen folgende Schritte durchfhren: Schritt 1: XML-MORE-BUFFER initialisieren Das Feld XML-MORE-BUFFER zeigt an, ob weitere in den Puffer zu schreibende Daten vorhanden sind. Bevor der Reader das erste Mal aufgerufen wird, sollte dieses Feld auf "F" (First) gesetzt werden.
XML Thunder
Initialisieren des Feldes XML-MORE-BUFFER Schritt 2: XML-BUFFER fllen Bei einem XML-Reader auf Knoten-Ebene braucht nicht das gesamte Dokument mit einem Aufruf des Handlers verarbeitet zu werden. Stattdessen kann das Dokument in Segmente aufgeteilt werden, die dem Handler in wiederholten Aufrufen bergeben werden. Nehmen wir zum Beispiel an, Sie htten aus praktischen Grnden einen XML-Reader auf KnotenEbene mit einer Puffergre von 5000 Zeichen definiert. Das bedeutet, dass der Handler bei jedem Aufruf bis zu 5000 Zeichen eines XML-Dokuments lesen kann. Nehmen wir auerdem an, dass der Handler verwendet wird, um ein XML-Dokument zu verarbeiten, dass 9000 Zeichen lang ist. Das folgende Beispiel zeigt, wie solch ein Dokument verarbeitet werden knnte: Das aufrufende Programm verschiebt die ersten 5000 Zeichen des XML-Dokuments in das Feld XML-BUFFER und reicht es an den Handler weiter.
XML Thunder
Weiterhin sei angenommen, dass auf Grund der von Handlern auf Knoten-Ebene bercksichtigten Regeln der Reader nur die ersten 3000 Zeichen verarbeitet, die er im Feld XML-BUFFER empfngt. Dann fhrt der Handler folgende Schritte aus: Die zugehrigen IDS-Felder auf Grundlage der ersten 3000 aus dem Puffer gelesenen XML-Zeichen fllen. Die 2000 ungelesenen Zeichen (Positionen 3001 bis 5000) an den Anfang des Puffers verschieben. Einen Zeiger setzen, der die erste leere Position im Puffer anzeigt (in diesem Fall Position 2001) und die Steuerung an das aufrufende Programm mit einem Rckgabecode "MD" ("More Data") zurckgeben.
Das aufrufende Programm hngt die nchsten 3000 Zeichen des ursprnglichen XML-Dokuments an das Feld XML-BUFFER an und ruft den Handler erneut auf. Das Pufferfeld fr 5000 Zeichen enthlt nun die Positionen 3001 bis 8000 des ursprnglichen XML-Dokuments.
Den nchsten Teil des XML-Dokuments an das Ende des Puffers anhngen
XML Thunder
Angenommen, der Reader verarbeitet aufgrund der von Handlern auf Knoten-Ebene bercksichtigten Regeln nur die ersten 4000 Zeichen aus dem Feld XML-BUFFER. Dann fhrt der Handler folgende Schritte aus: Die zugehrigen IDS-Felder auf Grundlage der 4000 aus dem Puffer gelesenen XML-Zeichen fllen. Die ungelesenen Zeichen (Positionen 4001 bis 5000) an den Anfang des Puffers verschieben. Einen Zeiger setzen, der die erste leere Position im Puffer anzeigt (in diesem Fall Position 1001) und die Steuerung an das aufrufende Programm mit einem Rckgabecode "MD" ("More Data") zurckgeben.
Den ungelesenen Teil an den Anfang des Puffers verschieben
Das aufrufende Programm hngt die nchsten 1000 Zeichen des ursprnglichen XML-Dokuments an das Ende des Feldes XML-BUFFER an und ruft den Handler erneut auf. Das Pufferfeld fr 5000 Zeichen enthlt nun die Positionen 7001 bis 9000 des ursprnglichen XML-Dokuments.
Den Rest des XML-Dokuments an das Ende des Puffers anfgen
XML Thunder
Angenommen, dass auf Grund der von Handlern auf Knoten-Ebene bercksichtigten Regeln der Reader die verbleibenden 2000 Zeichen verarbeitet, die er im Feld XML-BUFFER empfngt. Dann fhrt der Handler folgende Schritte aus: Die zugehrigen IDS-Felder auf Grundlage der 2000 aus dem Puffer gelesenen XML-Zeichen fllen. Die Steuerung mit einem Rckgabecode "OK" an das aufrufende Programm zurckgeben, um anzuzeigen, dass die Verarbeitung komplett abgeschlossen ist. Der von XML Thunder generierte Test Harness enthlt ein Beispiel, wie der Puffer dem Handler zugefhrt werden sollte. Das Feld XML-BPTR-BUFFER zeigt auf die letzte verwendete Position im Puffer. Sie sollten das verbleibende XML-Dokuments ab der Position "XML-BPTR-BUFFER + 1" bis zur Lnge des Puffers anhngen.
bertragen des XML-Puffers an den XML-Reader
XML Thunder
Schritt 3: Handler aufrufen Der eigentliche Aufruf eines XML-Readers auf Knoten-Ebene, wie er im Test Harness generiert wird, ist unten gezeigt:
Aufrufen des XML-Readers
Nach jedem Aufruf des Handlers sollte der Puffer wieder gefllt werden - auf Grundlage der Regeln in Schritt 2 - und der Handler sollte wieder aufgerufen werden, bis das gesamte XML-Dokument verarbeitet ist. Wenn das XML-Dokument vollstndig gelesen wurde, wird der XML-MOREBUFFER auf "L" gesetzt und XML-RETURN-CODE auf "OK".
XML Thunder Spezialfelder

XML Thunder verwendet Spezialfelder um : 1. 2. zustzliche Informationen bereitzustellen, die XML-Reader beim Parsen gefunden haben, und eine bessere Kontrolle ber die XML-Ausgabe durch XML-Writer zu erhalten.
XML Thunder stellt 5 Spezialfelder bereit. 1. 2. 3. Optionale Feld -Flags, um anzuzeigen, ob ein optionales Feld einen Inhalt hat (fr Reader), bzw. ob es ausgegeben werden soll (fr Writer). Zhlerfeld fr wiederholte Strukturen um anzuzeigen, wie oft ein Element aufgetreten ist (Reader), bzw. wie viele ausgegeben werden sollten (Writer). Lngenfeld fr Felder mit variabler Lnge um die Lnge eines vorgefundenen Feldes anzuzeigen (fr Reader), bzw. wie viele Zeichen des Feldes ausgegeben werden sollen (fr Writer). Track-Pointer-Felder um die Anfangs- und Endposition eines Elements oder Attributs anzuzeigen (fr Reader) Gleitkomma-Felder- fr dezimale Genauigkeit dezimale Felder
4. 5.
Spezialfelder knnen auf der Standard-Ebene, Handler-Ebene oder Knoten-Ebene kontrolliert werden. Das Vorkommen der Lngenfelder ist jedoch das einzige Feld, das auf allen drei Ebenen kontrolliert werden kann.
Es gibt ein Spezialfeld in den Programm-Datenfeldern (IDS),die die API in den Handler bilden, aber es kommt nicht in der XML-Struktur vor. In der folgenden IDS sind alle 5 Spezialfeld-Typen enthalten.
Zhlerfeld
Das Zhlerfeld wird zur Kontrolle wiederholter Strukturen verwendet. Fr jede wiederholte Struktur im Handler-Design wird automatisch ein Zhlerfeld in die IDS eingefgt. Das Zhlerfeld wird: von einem XML-Reader zurckgegeben, um anzuzeigen, wie oft ein Element in der geparsten XML-Instanz vorgekommen ist. Bei einem Handler auf Dokument-Ebene enthlt das Zhlerfeld die Gesamtzahl des Auftretens. Bei einem Handler auf Knoten-Ebene zeigt das Zhlerfeld an, ob der Handler das letzte Element einer wiederholten Struktur zurckgibt (Zhler = 1) oder ob noch weitere Elemente zurckzugeben sind (Zhler > 1). an einen XML-Writer bergeben, um anzuzeigen, wie viele Elemente einer wiederholten Struktur ausgegeben werden sollen. Bei einem Handler auf Dokument-Ebene enthlt das Zhlerfeld die Gesamtzahl der auszugebenden Elemente. Bei einem Handler auf Knoten-Ebene zeigt das Zhlerfeld an, ob der Handler das letzte Element einer wiederholten Struktur empfngt oder ob noch weitere Elemente auszugeben sind.
Optionales Flag-Feld
Wenn die Eigenschaft "Optional Flag Field" fr einen Knoten auf "true" gesetzt ist, enthlt die generierte IDS ein zustzliches "flag field", das dem Knoten zugeordnet ist. Ein optionales Flag-Feld wird von einem XML-Reader zurckgegeben, um anzuzeigen, ob in der XML-Instanz ein Knoten gefunden wurde. Wenn der Wert des Flags auf 1 gesetzt ist, wurde der Knoten gefunden und der Inhalt des IDS-Feldes ist der im Dokument gefundene. Wenn der Wert des Flags 0 ist, wurde der Knoten nicht gefunden und der im IDS-Feld zurckgegebene Inhalt ist der Initialisierungs-Wert. an einen XML-Writer bergeben, um anzuzeigen, ob ein optionaler Knoten unterdrckt werden soll. Wenn der Wert des Flags auf 1 gesetzt ist, wird der Knoten ausgegeben. Wenn der des Flags auf 0 gesetzt ist, wird der Knoten nicht ausgegeben.
XML Thunder
Lngenfeld
Das Lngenfeld wird verwendet, um die Lnge eines Feldes mit variabler Lnge zu beeinflussen. Wenn die Eigenschaft "Variable Length" fr einen Knoten auf "true" eingestellt ist, wird automatisch eine Lngenfeld fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Das Lngenfeld wird von einem XML-Reader zurckgegeben, um die Lnge des gelesenen Feldes anzuzeigen an einen XML-Writer weitergereicht, um anzuzeigen, wie viele Zeichen des Inhalts fr den Knoten ausgegeben werden sollen.
Track-Pointer
Track-Pointer werden verwendet, um die Anfangsposition des ffnenden Tags und die Endposition eines schlieenden Tags fr einen Knoten anzuzeigen. Wenn die Eigenschaft "Track Pointers" auf "true" gesetzt ist, werden 2 Felder (eines fr die Anfangsposition und eines fr das Ende) automatisch fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Track-Pointer werden nur von XML-Readern verwendet. Der Reader gibt die Anfangs- und EndPosition des jeweiligen XML-Knotens wieder.
Erweiterte Genauigkeit
Das Feld "Extended Precision" wird verwendet, um die dezimale Genauigkeit fr ein numerisches Feld festzulegen, das Dezimalstellen enthlt. Wenn die Eigenschaft auf "true" gesetzt ist, wird automatisch ein Feld mit erweiterter Genauigkeit in die IDS eingefgt und das ursprngliche Feld in ein Feld fr Integer-Werte (ohne Dezimalstellen) konvertiert. Zum Beispiel wird ein Feld mit einer COBOL-Deklaration PIC 9(11)V9(2) in zwei Felder konvertiert: Eines mit einer Deklaration PIC 9(13), um alle Ziffern des Inhalts aufzunehmen (integer und dezimal) Eines mit einer Deklaration PIC S9(3), um aufzunehmen, wie viele Dezimalstellen der Wert enthlt (z.B. -3 zeigt an, dass es 3 Dezimalstellen gibt.
Das Feld Extended Precision wird von einem XML-Reader wiedergegeben, um anzuzeigen, wie viele Dezimalstellen im Dokument gefunden wurden.
Generieren von Spezialfeldern in einem separaten Bereich der IDS

Mit XML Thunder knnen Sie bestimmen, wie die Spezialfelder in der IDS generiert werden. Per Voreinstellung werden sie direkt ber ihren zugehrigen Feldern wie unten gezeigt generiert.
XML Thunder
Bei Bedarf kann XML Thunder so eingestellt werden, dass die Spezialfelder in einem separaten Bereich der IDS generiert werden. Dies kann auf der Toolset- oder Handler-Ebene eingestellt werden.
Wenn Sie Spezialfelder in einem separaten Bereich auf Handler-Ebene generieren mchten, klicken Sie auf "XML Handler -> Properties -> Code Generation" und whlen Sie More Options aus.
Dann whlen Sie im Dropdown-Feld "Separate special fields" den Wert "True" aus.
XML Thunder
Dies bewirkt, dass die Spezialfelder in ihrer eigenen separaten 01-Ebene in der IDS generiert werden.
XML Thunder
XML Thunder
Lernprogramme
1. Erstellen eines XML-Handlers unter Verwendung einer COBOL Datenstruktur

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie eine COBOL-Programm-Datenstruktur haben Sie kein XML-Schema oder Beispiel-Dokument haben. Die XML-Struktur wird aus den Programm-Datenfeldern aufgebaut.
Schritt 1: Starten Sie XML Thunder. Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXMLHandler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
Wenn der Assistent das Einfhrungs-Fenster ffnet, klicken Sie auf Next.
116 Lernprogramme
XML Thunder
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Im Fenster "Source" whlen Sie fr die IDS-Quelle "Data Structure - COBOL" aus und setzen das Feld "Location" auf Program Files\CANAM\XML ThunderV4\Tutorials\COBOL Copybooks\BANKREC.cpy Stellen Sie "Derive from IDS" als Ihre XML-Quelle ein. Klicken Sie auf "Next", um fortzufahren.
Schritt 3: Geben Sie zustzliche IDS-Eigenschaften ein Akzeptieren Sie im Fenster Properties die Standardwerte fr die Identifiers und setzen Sie dasCOBOL code format auf Fixed format. Klicken Sie auf "Next", um fortzufahren.
XML Thunder
Lernprogramme 117
Schritt 4: Besttigen Sie die Auswahl Im Fenster Summary knnen Sie Ihre Auswahl berprfen und zum Beenden auf Finish klicken.
XML Thunder erstellt ein XML-Handler-Design, in dem die IDS auf dem bereitgestellten COBOLCopybook beruht und das XML aus der IDS abgeleitet wird. Jede IDS-Gruppe ist zu einem XMLElement geworden. Die IDS-Felder werden entweder in Elemente oder in Attribute umgewandelt, je nach Einstellung im Men "Tools -> Defaults -> IDS Rules". Die Abbildung der IDS-Felder auf die XML-Knoten erfolgt automatisch.
Schritt 5: Generieren der XML-Handler
118 Lernprogramme
XML Thunder
Klicken Sie auf "Generate"
oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
Auf der Registerkarte "XML Reader": Whlen Sie den XML-Reader, die IDS (Interface Data Structure) und den Test Harness fr die Generierung aus. Stellen Sie die Quellennamen BNKRECR, BNKRECRC und BNKRECRT ein. Wechseln Sie im Test Harness zum Fensterausschnitt "More Options" und stellen Sie das Feld "Read XML from" auf "External file" und "Output Data" auf "Display".
Auf der Registerkarte "XML Writer": Whlen Sie XML-Writer, IDS (Interface Data Structure) und Test Harness fr die Generierung aus. Setzen Sie die Quellennamen auf BNKRECW, BNKRECWC und BNKRECWT. Wechseln Sie im Test Harness in den Fensterausschnitt "More Options" und stellen Sie das Feld "Output Data To" auf "File".
Klicken Sie auf "Generate".
Wenn die Generierung abgeschlossen ist, sollten sechs COBOL-Quellcode-Dateien erstellt worden sein.
XML Thunder
BNKRECR.cbl - Der XML-Reader BNKRECRC.CPY - Das Copybook zur Untersttzung der API zum XML-Reader BNKRECRT.cbl - Der Test Harness fr den XML-Reader BNKRECW.cbl - Der XML-Writer
Lernprogramme 119
BNKRECWC.cpy - Das Copybook zur Untersttzung der API zum XML-Writer BNKRECWT.cbl - Der Test Harness fr den XML-Writer
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Die "Test Harness"-Programme sind vollstndig funktionsfhige, unabhngige Programme, die ausgefhrt werden knnen, um die XML-Handler zu testen. Eventuell mssen Ihrer Plattform entsprechende, kleinere nderungen an Test Harness und JCL vorgenommen werden, um die Dateiverarbeitung zu untersttzen. Das Testprogramm fr den Writer verwendet Dummy-Daten als Inhalte fr die von ihm erstellte XML-Instanz. ffnen Sie das Programm BNKRECWT.cbl und ndern Sie die folgende Zeile: Von: MOVE "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" TO BANK-Name-0006(XMLGVW-I1) Nach: MOVE "Your Company Name" TO BANK-Name-0006(XML-GVW-I1)
Speichern Sie diese nderung, kompilieren Sie alle geffneten Dateien und fhren Sie BNKRECWT.cbl aus. (das Testprogramm). Es sollte eine Datei mit dem Namen BNKREC.xml, die folgenderweise aussieht:
Fhren Sie BNKRECRT.cbl aus. Der XML-Reader wird vom Testprogramm aufgerufen, das dann dasselbe XML-Dokument zurck nach COBOL einliest.
2. Erstellen eines XML-Handlers unter Verwendung eines XMLSchemas

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie ein XML-Schema haben, das die Regeln fr Ihre XML-Struktur enthlt.
Schritt 1: Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen "Create a New XML Handler" und "Open an existing XML Handler" zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
120 Lernprogramme
XML Thunder
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Im Fenster Source setzen Sie die XML-Quelle auf XML Schema, setzen Sie als "Location of XML Source" Program files\Xml ThunderV4\tutorial\XML Schema Samples\BAXSD.xsd und als Ihre "IDS source" setzen Sie Derive from XML. Klicken Sie auf "Next", um fortzufahren.
Schritt 3: Geben Sie zustzliche Eigenschaften ein bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und setzen Sie das XML Root Element auf BANK. Klicken Sie auf "Next", um fortzufahren.
XML Thunder Lernprogramme 121
Schritt 4: Besttigen Sie die Auswahl Im Fenster Summary knnen Sie die Auswahl berprfen und zum Beenden auf Finish klicken.
XML Thunder erstellt ein XML-Handler-Design mit der XML-Struktur auf Grundlage des bereitgestellten Schemas und der aus dem XML abgeleiteten IDS. Die Abbildung von IDS-Feldern auf XML-Knoten erfolgt automatisch.
122 Lernprogramme
XML Thunder
Schritt 5: Generieren der XML-Handler Klicken Sie auf Generate oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
XML Thunder
Lernprogramme 123
Wenn die Generierung abgeschlossen ist, sollten sechs COBOL-Quellcode-Dateien erstellt worden sein. BNKRECR.cbl - Der XML-Reader BNKRECRC.CPY - Das Copybook zur Untersttzung der API zum XML-Reader BNKRECRT.cbl - Der Test Harness fr den XML-Reader BNKRECW.cbl - Der XML-Writer BNKRECWC.cpy - Das Copybook zur Untersttzung der API zum XML-Writer BNKRECWT.cbl - Der Test Harness fr den XML-Writer
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Die "Test Harness"-Programme sind vollstndig funktionsfhige, unabhngige Programme, die ausgefhrt werden knnen, um die XML-Handler zu testen. Eventuell mssen Ihrer Plattform entsprechende, kleinere nderungen an Test Harness und JCL vorgenommen werden, um die Dateiverarbeitung zu untersttzen. Das Testprogramm fr den Writer verwendet Dummy-Daten als Inhalte fr die von ihm erstellte XML-Instanz. ffnen Sie das Programm BNKRECWT.cbl und ndern Sie die folgende Zeile: Von: MOVE "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" TO BANK-Name-0005 MOVE 9 TO BANK-Name-len-0006 Nach: MOVE "Your Company Name" TO BANK-Name-0005 MOVE 30 TO BANK-Name-len-0006
Speichern Sie diese nderung, kompilieren Sie alle geffneten Dateien und fhren Sie BAXSDWT.cbl aus. (das Testprogramm). Es sollte BAXSD.xml erstellen.
124 Lernprogramme
XML Thunder
Die generierte XML-Datei sieht folgenderweise aus:
3. Erstellen eines XML-Handlers unter Verwendung einer XMLInstanz

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie ein Beispiel XML-Dokument haben. Sie kein XML-Schema haben. Die XML-Struktur wird auf Grundlage des Beispiel-XMLDokuments erstellt.
Beachten Sie, dass es immer besser ist, ein XML-Schema fr die XML-Struktur zu verwenden. Die XML-Knoten-Eigenschaften und Validierungsregeln beruhen auf dem Inhalt des Beispiel-XMLDokuments. Diese Eigenschaften und Regeln knnen nur so gut sein, wie der Inhalt des BeispielXML-Dokuments. Die besten Resultate erhalten Sie, wenn das Beispieldokument die Extremflle enthlt, also jeder Knoten bis zu seiner maximalen Lnge gefllt ist, wiederholte Strukturen die maximale Anzahl von Wiederholungen haben, etc.. Schritt 1: Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Setzen Sie im Fenster Source die XML-Quelle auf Derive from XML Instance und setzen Sie das Location-Feld auf Program files\Xml ThunderV4\tutorial\XML Samples Instances\BAXSD.xml Whlen Sie Derive from XML als Ihre IDS-Quelle aus. Klicken Sie auf "Next", um fortzufahren.
Schritt 3: Geben Sie zustzliche IDS-Eigenschaften ein bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und klicken Sie auf Next, um fortzufahren.
126 Lernprogramme XML Thunder
XML Thunder erstellt ein XML-Handler-Design mit der XML-Struktur auf Grundlage des bereitgestellten Beispiel-XML-Dokuments und der aus dem XML abgeleiteten IDS. Die Abbildung von IDS-Feldern auf XML-Knoten erfolgt automatisch.
Schritt 4: ndern von Eigenschaften Wenn ein Handler aus einem Beispiel-XML-Dokument erstellt wird, mssen oft manche der eingerichteten Eigenschaften gendert werden. In diesem Fall enthielt das Beispiel-Dokument nur 2 ACCOUNT-Elemente. Wir ndern den Knoten ACCOUNT und setzen die Eigenschaft "Max Occ" auf 40.
XML Thunder
Lernprogramme 127
Der Knoten ACCOUNT-Comment darf lnger sein als der im Beispiel-XML-Dokument vorgefundene Kommentar. ndern Sie den Datenknoten ACCOUNT-Comment und setzen Sie die Eigenschaft length auf 4000. Vergewissern Sie sich auch, dass die Option variable length aktiviert ist.
Achten Sie auf die nderung in der IDS-Liste. Die Lnge des IDS-Knotens wurde auf 4000 erhht.
Die Logische IDS sollte nun folgenderweise aussehen:

Schritt 5: Generieren der XML-Handler Klicken Sie auf "Generate" oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
Klicken Sie auf "Generate.
XML Thunder
Lernprogramme 129
Wenn die Generierung abgeschlossen ist, sollten sechs COBOL-Quellcode-Dateien erstellt worden sein. BNKRECR.cbl - Der XML-Reader BNKRECRC.CPY - Das Copybook zur Untersttzung der API zum XML-Reader BNKRECRT.cbl - Der Test Harness fr den XML-Reader BNKRECW.cbl - Der XML-Writer BNKRECWC.cpy - Das Copybook zur Untersttzung der API zum XML-Writer BNKRECWT.cbl - Der Test Harness fr den XML-Writer
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Die "Test Harness"-Programme sind vollstndig funktionsfhige, unabhngige Programme, die ausgefhrt werden knnen, um die XML-Handler zu testen. Eventuell mssen Ihrer Plattform entsprechende, kleinere nderungen an Test Harness und JCL vorgenommen werden, um die Dateiverarbeitung zu untersttzen. Das Testprogramm fr den Writer verwendet Dummy-Daten als Inhalte fr die von ihm erstellte XML-Instanz. ffnen Sie das Programm BNKRECWT.cbl und ndern Sie die folgende Zeile: Von: MOVE "XXXXXXXXXX" TO BANK-Name-0005(XML-GVW-I1) Nach: MOVE "Your company name" TO BANK-Name-0005(XML-GVW-I1)
Speichern Sie diese nderung, kompilieren Sie alle geffneten Dateien und fhren Sie BNKRECWT.cbl aus. (das Testprogramm). Es sollte BNKREC.xml erstellen.
130 Lernprogramme
XML Thunder
4. Erstellen eines XML-Handlers unter Verwendung eines COBOL-Programms

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie eine COBOL-Programm-Datenstruktur haben Sie kein COBOL-Copybook haben Sie kein XML-Schema oder Beispiel-Dokument haben. Die XML-Struktur wird aus den Programm-Datenfeldern aufgebaut.
Schritt 1: Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
XML Thunder
Lernprogramme 131
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Im Fenster Source whlen Sie fr die IDS-Quelle Data Structure - COBOL aus und setzen das Feld "Location" auf Program files\Xml ThunderV4\tutorial\COBOL Programs\BAXSD.cbl. Stellen Sie Derive from IDS als Ihre XML-Quelle ein. Klicken Sie auf "Next", um fortzufahren.
Der Assistent parst das COBOL-Programm und zeigt alle verfgbaren Datenfelder, um die IDS entwerfen zu knnen. Whlen Sie die Datenstruktur 01 BANK aus und klicken Sie auf >> (Alle nach rechts). Alle Felder in der Datenstruktur werden in den Bereich Selected fields kopiert. Klicken Sie auf "Next", um fortzufahren.
132 Lernprogramme
XML Thunder
Schritt 3: Geben Sie zustzliche IDS-Eigenschaften ein bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und setzen Sie das COBOL code format auf Fixed format. Klicken Sie auf "Next", um fortzufahren.
XML Thunder erstellt ein XML-Handler-Design, in dem die IDS auf der COBOL-ProgrammDatenstruktur beruht und das XML aus der IDS abgeleitet wird. Jede IDS-Gruppe ist zu einem XMLElement geworden. Die IDS-Felder werden entweder in Elemente oder in Attribute umgewandelt, je nach Einstellung im Men "Tools -> Defaults -> IDS Rules". Die Abbildung von IDS-Feldern auf XML-Knoten erfolgt automatisch.
XML Thunder
Lernprogramme 133
Schritt 4: ndern Sie ein paar Eigenschaften Klicken Sie in der XML-Liste mit der rechten Maustaste auf XTCPY-BANK-Incorporation-Date und whlen Sie Properties aus, ndern Sie sein Format auf Date und vergewissern Sie sich, dass "Sequence" auf yMd steht und "Separator" auf - :
134 Lernprogramme
XML Thunder
ndern Sie den XML-Datenknoten XTCPY-ACCOUNT-Opening-Date auf Date. ndern Sie den XML-Datenknoten XTCPY-ACCOUNT-Opening-Date auf Time. Am Ende sollte das Fenster "Logical IDS" so aussehen:
XML Thunder
Lernprogramme 135
Das Fenster "Edit XML" sollte wie folgt aussehen:
Schritt 5: Generieren der XML-Handler Klicken Sie auf "Generate" oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
Auf der Registerkarte "XML Reader": whlen Sie den XML-Reader und die IDS (Interface Data Structure) fr die Generierung aus. Stellen Sie die Quellennamen BNKRECR und BNKRECRC ein.
Auf der Registerkarte "XML Writer": whlen Sie den XML-Writer und die IDS (Interface Data Structure) fr die Generierung aus. Setzen Sie die Quellennamen auf BNKRECW und BNKRECWC.
136 Lernprogramme
XML Thunder
Wenn die Generierung abgeschlossen ist, sollten sechs COBOL-Quellcode-Dateien erstellt worden sein. BNKRECR.cbl - Der XML-Reader BNKRECRC.CPY - Das Copybook zur Untersttzung der API zum XML-Reader BNKRECW.cbl - Der XML-Writer BNKRECWC.cpy - Das Copybook zur Untersttzung der API zum XML-Writer
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Rufen Sie den XML-Reader oder XML-Writer in Ihrem Hauptprogramm auf. Beispiele dafr, wie der Aufruf aussehen sollte, finden Sie in den generierten Test-HarnessProgrammen fr die einzelnen Handler.
5. Erstellen eines Handlers aus einer WSDL

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie eine WSDL haben, in der die Regeln fr Ihre XML-Struktur enthalten sind.
Der XML-Reader und -Writer kann SOAP-Nachrichten lesen und erstellen. Schritt 1: Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
Lernprogramme 137
XML Thunder
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Setzen Sie im Fenster Source die XML-Quelle auf XML Structure -> WSDL und setzen Sie das Location-Feld auf Program files\Xml ThunderV4\tutorial\WSDL Samples\GlobalWeathers.wsdl. Whlen Sie Derive from XML als Ihre IDS-Quelle aus. Klicken Sie auf "Next", um fortzufahren.
138 Lernprogramme
XML Thunder
Schritt 3: Geben Sie zustzliche Eigenschaften ein bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und whlen Sie die Input-Nachricht "GetWeather" aus. Klicken Sie auf "Next", um fortzufahren.
XML Thunder
Lernprogramme 139
XML Thunder erstellt ein XML-Handler-Design mit der XML-Struktur auf Grundlage der bereitgestellten WSDL und der aus dem XML abgeleiteten IDS. Die Abbildung von IDS-Feldern auf XML-Knoten erfolgt automatisch.
Schritt 5: Generieren der XML-Handler Klicken Sie auf "Generate" aus. oder whlen Sie im Hauptmen "Tools -> Generate..."
Auf der Registerkarte "XML Reader": Whlen Sie den XML-Reader, die IDS (Interface Data Structure) und den Test Harness fr die Generierung aus. Setzen Sie die Quellen-Namen auf GLOBALWEATHERR, GLOBALWEATHERRC und GLOBALWEATHERRT.
Auf der Registerkarte "XML Writer": Whlen Sie XML-Writer, IDS (Interface Data Structure) und Test Harness fr die Generierung aus.
140 Lernprogramme
XML Thunder
Setzen Sie die Quellen-Namen auf GLOBALWEATHERW, GLOBALWEATHERWC und GLOBALWEATHERWT.
Klicken Sie auf "Generate.
Wenn die Generierung abgeschlossen ist, sollten sechs COBOL-Quellcode-Dateien erstellt worden sein. GLOBALWEATHERR.cbl - Der XML-Reader GLOBALWEATHERRC.CPY - Das Copybook zur Untersttzung der API zum XML-Reader GLOBALWEATHERRT.cbl - Der Test Harness fr den XML-Reader GLOBALWEATHERW.cbl - Der XML-Writer GLOBALWEATHERWC.cpy - Das Copybook zur Untersttzung der API zum XML-Writer GLOBALWEATHERWT.cbl - Der Test Harness fr den XML-Writer
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Rufen Sie den XML-Reader oder XML-Writer in Ihrem Hauptprogramm auf. Beispiele dafr, wie der Aufruf aussehen sollte, finden Sie in den generierten Test-HarnessProgrammen fr die einzelnen Handler.
XML Thunder
Lernprogramme 141
6. Erstellen eines Handlers aus einer DTD

In diesem Lernprogramm wird demonstriert, wie ein XML-Handler erstellt wird, wenn: Sie eine DTD haben, in der die Regeln fr Ihre XML-Struktur enthalten sind.
Schritt 1: Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche.
142 Lernprogramme
XML Thunder
Schritt 2: Whlen Sie die IDS- und XML-Quellen aus. Im Fenster Source whlen Sie fr die IDS-Quelle Data Structure - COBOL aus und setzen das Location-Feld auf "Program files\Xml Thunder\tutorial\DTD Samples\MORTGAGE.DTD". Stellen Sie Derive from IDS als Ihre XML-Quelle ein. Klicken Sie auf Next.
Schritt 3: Geben Sie zustzliche Eigenschaften ein bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und setzen Sie das XML Root Element auf MI_RESPONSE. Klicken Sie auf "Next", um fortzufahren.
XML Thunder
Lernprogramme 143
XML Thunder erstellt ein XML-Handler-Design mit der XML-Struktur auf Grundlage der bereitgestellten DTD und der aus dem XML abgeleiteten IDS. Die Abbildung von IDS-Feldern auf XML-Knoten erfolgt automatisch.
Schritt 5: Generieren der XML-Handler Klicken Sie auf "Generate oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
Auf der Registerkarte "XML Reader": Whlen Sie den XML-Reader, die IDS (Interface Data Structure) und den Test Harness fr die Generierung aus. Setzen Sie die Quellnamen auf MORTGAGER, MORTGAGERC and MORTGAGERT. Wechseln Sie im Test Harness zum Fensterausschnitt "More Options" und stellen Sie das Feld "Read XML from" auf "External file" und "Output Data" auf "Display".
Auf der Registerkarte "XML Writer":

144 Lernprogramme
Whlen Sie XML-Writer, IDS (Interface Data Structure) und Test Harness fr die Generierung aus. Setzen Sie die Quellennamen auf MORTGAGEW, MORTGAGEWC and MORTGAGEWT.
XML Thunder
Wechseln Sie im Test Harness in den Fensterausschnitt "More Options" und ndern Sie das Feld "Output Data To" auf "File".
Klicken Sie auf "Generate"
Schritt 6: Testen Sie die generierten Handler Der generierte COBOL-Quellcode kann auf die gleiche Weise kompiliert werden wie Ihre anderen COBOL-Programme. Die "Test Harness"-Programme sind vollstndig funktionsfhige, unabhngige Programme, die ausgefhrt werden knnen, um die XML-Handler zu testen. Eventuell mssen Ihrer Plattform entsprechende, kleinere nderungen an Test Harness und JCL vorgenommen werden, um die Dateiverarbeitung zu untersttzen.
XML Thunder
Lernprogramme 145
7. Arbeiten mit Spezialfeldern

In diesem Lernprogramm wird gezeigt, wie Sie Spezialfelder fr XML Thunder in Ihr HandlerDesign einfgen knnen. Spezialfelder werden in die IDS eingefgt, an einen XML-Handler bergeben und von ihm zurckgegeben. In der erstellten oder gelesenen XML-Instanz stehen sie jedoch nicht. Spezialfeldern ermglichen eine bessere Kontrolle ber das verarbeitete XML. Schritt 1: Erstellen Sie den XML-Handler Erstellen Sie einen XML-Handler aus BAXSD. (Siehe Lernprogramm 1).
Schritt 2: Fgen Sie ein Spezialfeld "Variable Length" hinzu Das Lngenfeld wird verwendet, um die Lnge eines Feldes mit variabler Lnge zu beeinflussen. Wenn die Eigenschaft "Variable Length" fr einen Knoten auf "true" eingestellt ist, wird automatisch eine Lngenfeld fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Das Lngenfeld wird von einem XML-Reader zurckgegeben, um die Lnge des gelesenen Feldes anzuzeigen an einen XML-Writer weitergereicht, um anzuzeigen, wie viele Zeichen des Inhalts fr den Knoten ausgegeben werden sollen.
Wenn Sie ein Lngen-Spezialfeld hinzufgen mchten, whlen Sie den KnotenAccount-Comment aus und setzen die Eigenschaft "Variable Length" auf True.
Ein Lngen-Spezialfeld wird in die physische IDS eingefgt. Der Name des Feldes ist der gleiche wie der des ursprnglichen Feldes, nur dass ein "-len" an sein Ende angefgt wird.
Schritt 3: Fgen Sie ein Spezialfeld "Optional Flag Field" ein Wenn die Eigenschaft "Optional Flag Field" fr einen Knoten auf "true" gesetzt ist, enthlt die generierte IDS ein zustzliches "flag field", das dem Knoten zugeordnet ist.
Ein optionales Flag-Feld wird von einem XML-Reader zurckgegeben, um anzuzeigen, ob in der XML-Instanz ein Knoten gefunden wurde. Wenn der Wert des Flags auf 1 gesetzt ist, wurde der Knoten gefunden und der Inhalt des IDS-Feldes ist der im Dokument gefundene. Wenn der Wert des Flags 0 ist, wurde der Knoten nicht gefunden und der im IDS-Feld zurckgegebene Inhalt ist der Initialisierungs-Wert. an einen XML-Writer bergeben, um anzuzeigen, ob ein optionaler Knoten unterdrckt werden soll. Wenn der Wert des Flags auf 1 gesetzt ist, wird der Knoten ausgegeben. Wenn der des Flags auf 0 gesetzt ist, wird der Knoten nicht ausgegeben.
Wenn Sie ein optionales Flag-Feld in die IDE einfgen mchten, whlen Sie den Knoten "AccountComment" aus und setzen die Eigenschaft "Optional Flag Field" auf "True".
Ein "Optional Flag Field"-Spezialfeld wird in die physische IDS eingefgt. Der Name des Feldes ist der gleiche wie der des ursprnglichen Feldes, nur dass ein "-flag" an sein Ende angefgt wird.
148 Lernprogramme
XML Thunder
Schritt 4: Fgen Sie ein Spezialfeld "Track Pointers" ein Track-Pointer werden verwendet, um die Anfangsposition des ffnenden Tags und die Endposition eines schlieenden Tags fr einen Knoten anzuzeigen. Wenn die Eigenschaft "Track Pointers" auf "true" gesetzt ist, werden 2 Felder (eines fr die Anfangsposition und eines fr das Ende) automatisch fr das entsprechende Programm-Datenfeld in die IDS eingefgt. Track-Pointer werden nur von XML-Readern verwendet. Der Reader gibt die Anfangs- und EndPosition des jeweiligen XML-Knotens wieder. Wenn Sie Track-Pointer in die IDS einfgen mchten, whlen Sie den Knoten "Account-Comment" aus und setzen die Eigenschaft "Track Pointers" auf "True".
XML Thunder
Lernprogramme 149
Ein "Track Pointers"-Spezialfeld wird in die physische IDS eingefgt. Der Name des Feldes ist der gleiche wie der des ursprnglichen Feldes, nur dass ein "-flag" an sein Ende angefgt wird.
Schritt 5: Fgen Sie ein Spezialfeld "Extended Precision" ein Das Feld "Extended Precision" wird verwendet, um die dezimale Genauigkeit fr ein numerisches Feld festzulegen, das Dezimalstellen enthlt. Wenn die Eigenschaft auf "true" gesetzt ist, wird automatisch ein Feld mit erweiterter Genauigkeit in die IDS eingefgt und das ursprngliche Feld in ein Feld fr Integer-Werte (ohne Dezimalstellen) konvertiert. Zum Beispiel wird ein Feld mit einer COBOL-Deklaration PIC 9(11)V9(2) in zwei Felder konvertiert: Eines mit einer Deklaration PIC 9(13), um alle Ziffern des Inhalts aufzunehmen (integer und dezimal) Eines mit einer Deklaration PIC S9(3), um aufzunehmen, wie viele Dezimalstellen der Wert enthlt (z.B. -3 zeigt an, dass es 3 Dezimalstellen gibt.
Das Feld Extended Precision wird von einem XML-Reader wiedergegeben, um anzuzeigen, wie viele Dezimalstellen im Dokument gefunden wurden. Wenn Sie das Feld "Extended Precision" in die IDS einfgen mchten, whlen Sie den Knoten "Account-Balance" aus und setzen Sie die Eigenschaft "Extended Precision" auf "True".
8. Handler mit XML Choice

Starten Sie XML Thunder Im Startfenster stehen Ihnen die beiden Befehlsschaltflchen Create a New XML Handler und Open an existing XML Handler zur Verfgung. (Wenn Sie das Startfenster deaktiviert haben, klicken Sie bitte auf in der Symbolleiste, oder whlen Sie im MenXML-Handler -> New aus. In diesem Fall klicken Sie auf die erste Befehlsschaltflche
150 Lernprogramme
XML Thunder
Whlen Sie im Fenster "Source" den Eintrag XML Schema aus der Liste aus und klicken Sie auf Next. Setzen Sie im Fenster Source die XML-Quelle auf XML Schema und das Location-Feld auf tutorTX\XML Schema Samples\Bookstore.xsd. Whlen Sie Derive from XML als Ihre IDS-Quelle aus. Klicken Sie auf Next.
bernehmen Sie im Fenster Properties die Standardwerte fr die Identifiers und setzen Sie das XML Root Element auf Contact. Klicken Sie auf Next.
Im Fenster Summary knnen Sie die Auswahl berprfen und zum Beenden auf Finish klicken.
Nach kurzer Zeit wird das Entwurfs-Fenster fr den XML-Handler angezeigt. Es sollte folgenderweise aussehen:
Wir modifizieren den Knoten XT-XML-CHOICE-0001 node and ndern seinen Namen auf XTPHONE-CHOICE.
152 Lernprogramme
XML Thunder
Nehmen Sie die gleichen nderungen an folgenden Knoten vor: XT-XML-CHOICE-0002 und XTXML-CHOICE-0003, mit nderung der Namen auf: XT-WORK-PHONE-CHOICE und XTADDRESS-CHOICE Das XML-Handler-Design sollte nun folgenderweise aussehen:
Klicken Sie auf Generate
oder whlen Sie im Hauptmen "Tools -> Generate..." aus.
Im Dialogfenster "Generation": Registerkarte "XML-Reader": Whlen Sie den XML-Reader , die IDS (Interface Data Structure) und den Test Harness fr die Generierung aus. Setzen Sie die Quellennamen auf CUSTOMERR, CUSTOMERRC und CUSTOMERRT. ffnen Sie im Test Harness das Fenster "More Options" und ndern Sie Read XML aus External File. Output Data auf Display. Klicken Sie auf "Generate. Registerkarte XML-Writer: Whlen Sie XML-Writer , IDS (Interface Data Structure) und Test Harness fr die Generierung aus. Setzen Sie die Quellennamen auf CUSTOMERW, CUSTOMERWC und CUSTOMERWT. ffnen Sie im Test Harness das Fenster "More Options" und ndern Sie das Feld Output Data To auf File. Klicken Sie auf "Generate. (vorhandene Dateien berschreiben)
XML Thunder
Lernprogramme 153
Im Zielordner sollten Sie die Dateien CUSTOMERW.cbl, CUSTOMERR.cbl, CUSTOMERWC.cpy, CUSTOMERRC.cpy, CUSTOMERWT.cbl und CUSTOMERRT.cbl vorfinden; XML-Writer, Reader, IDS und Testprogramme fr Writer und Reader, in dieser Reihenfolge.
Starten Sie Ihre bevorzugte COBOL-IDE und laden Sie diese Dateien.
Wechseln Sie zum Programm CUSTOMERWT.cbl und suchen Sie das folgende Code-Segment:
XML-Choice-Strukturen werden mit dem Attribut Selection kontrolliert. Wenn wir whrend der Laufzeit einen XML-Writer aufrufen, sollten wir den vollstndig qualifizierten Namen des XMLElements verschieben, das wir in dieses IDS-Feld ausgeben mchten. Das Testprogramm zeigt alle mglichen Werte und es ist Aufgabe unserer Geschftslogik, die richtigen Werte zu verschieben. Umgekehrt verschiebt ein XML-Reader den vollstndig qualifizierten Namen des XML-Elements, das er beim Parsen des Quell-XML-Dokuments ins das IDS-Feld gefunden hat.
Nun modifizieren Sie den XML Writer Test Harness (CUSTOMERWT.cbl) und ndern folgendes: Von: MOVE "Contact.Customer.Address.XT-ADDRESS-CHOICE.CAN-Address" TO Selection0019(XML-GVW-I1, XML-GVW-I2) Nach: MOVE "Contact.Customer.Address.XT-ADDRESS-CHOICE.OtherCountry" TO Selection0019(XML-GVW-I1, XML-GVW-I2)
154 Lernprogramme
XML Thunder
Speichern Sie diese nderung, kompilieren Sie alle geffneten Dateien und fhren Sie BAXSDWT.cbl aus. Es sollte CUSTOMER.xml erstellen.
HINWEIS: Eine vollstndige Beschreibung der Untersttzung von XML Choice und COBOL Redefines finden Sie in den jeweiligen Kapiteln dieses Handbuchs.
9. Erstellen eines XML-Handlers auf Knoten-Ebene

Ein Handler auf Knoten-Ebene liest und schreibt XML-Dokumente auf Grundlage einer minimalen deklarierten Interface Definition Section (IDS). XML-Handler auf Knoten-Ebene unterscheiden sich von denen auf Dokument-Ebene dadurch, dass die IDS nicht so gro zu sein braucht, dass sie alle vorkommenden Datenfelder aufnehmen kann, die aus einem XML-Dokument gelesen oder dort hinein geschrieben werden. Ein XML-Handler auf Knoten-Ebene enthlt per Definition keine wiederholten Strukturen (COBOL-"occurs" oder C-Arrays). Stattdessen werden wiederholte Strukturen Stck fr Stck an den Handler bergeben. Dadurch kann der XML-Handler eine "unbegrenzte" Anzahl wiederholter Strukturen verarbeiten. Ein XML-Handler auf Knoten-Ebene liest und schreibt XML-Dokumente in Segmenten, die auf einer minimalen deklarierten Puffergre basieren. XML-Handler auf Knoten-Ebene unterscheiden sich von Handlern auf Dokument-Ebene insofern, dass das Feld XML-BUFFER nicht so gro definiert zu werden braucht, dass es ein ganzes XML-Dokument aufnehmen kann. Ein XML-Handler auf Knoten-Ebene kann XML-Dokumente unbegrenzter Gre lesen und schreiben, da es keine Beschrnkung fr die Gre der IDS und des XML-Dokuments selbst gibt. Die Erstellung eines XML-Handlers, der Funktionen der Knoten-Ebene verwendet, ist eine GenerierungsOption. Fr das Design braucht nichts Besonderes bercksichtigt zu werden. Dasselbe XMLThunder-Design kann fr die Generierung von Handlern auf Knoten-Ebene und auf Dokument-Ebene verwendet werden. Schritt 1 - Erstellen Sie einen neuen XML-Handler Einen neuen Handler knnen Sie auf jede in den Lernprogrammen 1 bis 4 beschriebene Weise erstellen (aus einer COBOL-Datenstruktur, einem XML-Schema, einer XML-Instanz oder einem COBOL-Programm). In diesem Lernprogramm beginnen wir jedoch damit, einen vorhandenen Handler umzubenennen. . ffnen Sie den Lernprogramm-Handler "BAXML_XML" ber den Menpunkt "XML Handler Open" und setzen Sie den aktuellen Ordner auf <application path>\CANAM\XML Thunder\Tutorials\data. Whlen Sie die Datei BAXML_XML.api.xml aus und klicken Sie auf Open.
XML Thunder
Lernprogramme 155
ffnen Sie das vorhandene Lernprogramm BAXML_XML a. Erstellen Sie eine neue Version des Handlers, indem Sie den Meneintrag "XML Handler Save As" auswhlen und den Dateinamen auf "BAXML_XML_MB.api.xml" setzen.
Speichern Sie das Lernprogramm "BAXML_XML" unter einem neuen Namen Schritt 2 - Definieren Sie einen XML-Handler auf Knoten-Ebene Wenn Sie einen Handler auf Knoten-Ebene generieren mchten, ffnen Sie das Men XML Item Properties Code Generation und setzen Sie den XML Handler Type auf Node-level XML Handler".
156 Lernprogramme
XML Thunder
Fr einen Handler auf Knoten-Ebene empfiehlt es sich, eine BUFFER-Gre zu whlen, die mindestens so gro ist wie der von XML Thunder im Eigenschaftenfenster unter "Calculated minimum" angezeigte Wert. Dadurch wird sichergestellt, dass der Puffer gro genug ist, um alle Zeichen aus dem Dokument aufzunehmen, einschlielich der ersten Iteration jeder wiederholten Struktur (die Menge, die mglicherweise von einem Handler auf Knoten-Ebene zurckgegeben werden knnte). Beachten Sie jedoch, dass das berechnete Minimum keine optionalen Knoten umfasst, weshalb Sie die Gre mglicherweise zu deren Bercksichtigung erhhen mssen. Wenn Sie einen Puffer festlegen, der kleiner ist als das, was mit einem Aufruf durch einen Handler auf Knoten-Ebene zurckgegeben werden kann, kann die Verarbeitung kompliziert werden. Zum Einstellen der Puffergre ffnen Sie das Eigenschaften-Fenster des XML Handlers durch Klicken auf: XML Item Properties General, wo Sie den Wert von "Buffer Size" entsprechend ndern.
Puffergre festlegen Schritt 3 - Generieren Sie einen XML-Handler auf Knoten-Ebene Klicken Sie auf "Generate" Im Dialogfenster "Generation":
Lernprogramme 157
oder whlen Sie im Hauptmen "Tools Generate " aus.
XML Thunder
ffnen Sie die Registerkarte "XML-Reader" und whlen Sie XML Reader, IDS (Interface Data Structure) und Test Harness zur Generierung aus. Setzen Sie die Quellennamen auf BAXMLRR, BAXMLRC und BAXMLRT. Klicken Sie auf die Schaltflche "More Options" fr den Test Harness und vergewissern Sie sich, dass die Einstellung fr "Read XML from" "Internal Buffer" ist und die Einstellung fr "Output data to" "Display" ist.
ffnen Sie die Registerkarte "XML-Writer" und whlen Sie XML Writer, IDS (Interface Data Structure) und Test Harness zur Generierung aus. Setzen Sie die Quellennamen auf BAXMLWR, BAXMLWC and BAXMLWT.
Einstellen der Quellennamen fr Reader und Writer
Klicken Sie auf "Generate" (vorhandene Dateien berschreiben) Schritt 4 - berprfen Sie die generierte IDS Die generierte IDS fr XML-Reader und -Writer sieht wie folgt aus:
158 Lernprogramme
XML Thunder
Die generierte IDS wie im Test Harness angezeigt Handler auf Knoten-Ebene haben keine "occurs" (fr COBOL) und keine Arrays (fr C-Programme). Stattdessen ist die IDS darauf ausgelegt, eine Iteration jeder wiederholten Struktur aufzunehmen. Ein XML-Writer-Handler wird fr jede Iteration einer wiederholten Struktur aufgerufen, whrend ein XML-Reader bei jedem Aufruf eine Iteration zurckgibt. Schritt 5 - Verbrauchen Sie die XML-Handler auf Knoten-Ebene Der von XML Thunder generierte Test Harness ist ein gutes Beispiel dafr, wie ein XML ThunderHandler aufzurufen ist. Es gibt einen kleinen Unterschied zwischen dem Aufruf eines Writers und dem eines Readers. Verbrauchen eines XML-Writers Die folgenden wichtigen Punkte werden durch den Beispiel-Test-Harness hervorgehoben. XML-MORE-BUFFER initialisieren Das Feld XML-MORE-BUFFER zeigt an, ob weitere in den Puffer zu schreibende Daten vorhanden sind. Bevor der Writer das erste Mal aufgerufen wird, sollte dieses Feld auf "F" (First) gesetzt werden.
Programmzeile im generierten Beispiel-Test-Harness zum Einstellen von XML-MORE-BUFFER
XML Thunder
Lernprogramme 159
IDS-Felder fllen Im Gegensatz zu XML-Handlern auf Dokument-Ebene werden XML-Handler auf Knoten-Ebene mehrmals aufgerufen. Wenn der XML-Writer-Handler das erste Mal aufgerufen wird, werden alle Daten bis zum ersten Auftreten eines wiederholten Elements auf niedrigster Ebene geschrieben. Bei anschlieenden Aufrufen des Handlers sollte das nchste Element der wiederholten Struktur auf niedrigster Ebene bergeben werden, bis alle verarbeitet wurden. Nachdem alle Daten fr eine wiederholte Struktur an den Handler bergeben wurden, sollten alle Daten bis zum ersten Element der niedrigsten Ebene des nchsten wiederholten Elements bergeben werden. Wie schon erwhnt empfiehlt es sich, den Puffer gro genug zu definieren, um die Datenmenge aufnehmen zu knnen, die von einem aufgerufenen XML-Writer zurckgegeben werden knnen. Zur Untersttzung der Verarbeitung wird fr jede wiederholte Struktur ein Zhlerfeld definiert. Obgleich Sie das Zhlerfeld nutzen knnen, um zu verfolgen, wie viele weitere Elemente noch ausgegeben werden mssen, prft der XML-Handler eigentlich nur, ob der Wert grer als Null ist. Wenn der Zhler fr eine wiederholte Struktur grer als Null ist, wird ein weiteres Element in das XML-Dokument geschrieben. Wenn der Zhler auf Null gesetzt wird, wird dem Handler damit mitgeteilt, dass keine weiteren Elemente auszugeben sind. Im folgenden Beispiel wird der Zhler bei jedem iterativen Aufruf des Befehls PERFORM um 1 verringert, um Beispieldaten zu generieren. Das gleiche Ergebnis kann dadurch erreicht werden, den Zhler auf 1 zu halten, whrend Elemente der wiederholten Struktur geschrieben werden, und ihn dann auf 0 zu setzen, wenn keine weiteren Eintrge mehr zu schreiben sind. Die folgenden Programmzeilen befinden sich im Handler-Abschnitt BUSINESS-LOGIC-BEFORE. In diesem Beispiel werden Dummy-Daten zum Fllen der Struktur BANK-0001 verwendet, einschlielich eines Elements der Struktur ACCOUNT-0005.
160 Lernprogramme
XML Thunder
Beispiel-Testprogramm zum Fllen der IDS Aufrufen des XML-Writers Es wird erwartet (obwohl nicht mit Sicherheit), dass ein XML-Writer auf Knoten-Ebene mehr als einmal aufgerufen werden muss, um das XML-Dokument zu erstellen. Das hat folgende Grnde: XML-Writer auf Knoten-Ebene erhalten per Definition bei jedem Aufruf nur eine Iteration einer wiederholten Struktur. Wenn die IDS wiederholte Strukturen enthlt, muss der XML-Writer einmal fr jede Iteration aufgerufen werden. Writer auf Knoten-Ebene fllen ein Dokument nur bis zu der Gre, die fr das Feld XML-BUFFER festgelegt ist. Wenn das zu erstellende Dokument grer als XML-BUFFER ist, werden weitere Aufrufe des XML-Writers erforderlich.
Beispiel-Code im Test Harness zum Aufruf eines XML-Writers
XML Thunder
Lernprogramme 161
Den Puffer lschen Wenn auf Knoten-Ebene generiert wird, wird das Feld XML-BUFFER bei jedem Aufruf des Handlers wiederverwendet. Aus diesem Grund muss der Puffer nach jedem Aufruf in einen anderen Speicherbereich verschoben werden (Datei, Datenbank, etc.), um Datenverlust zu vermeiden. Im Beispiel des Testprogramms wird der Puffer nach jedem Handler-Aufruf einfach auf der Konsole ausgegeben. Im Feld XML-BPTR-BUFFER steht, wie viele Zeichen vom Handler in das Feld XMLBUFFER geschrieben wurden. Wenn zum Beispiel das Feld XML-BUFFER mit einer Lnge von 5000 Zeichen definiert wurde und im Feld XML-BPTR-BUFFER die Zahl 700 steht, dann sollten nur die ersten 700 Zeichen aus XML-BUFFER verwendet werden.
Beispiel-Code im Test Harness zum Aufruf eines XML-Writers Wenn das XML-Dokument vollstndig in den Puffer geschrieben wurde, wird der XML-MOREBUFFER auf "L" gesetzt und XML-RETURN-CODE auf "OK".
Verbrauchen eines XML-Readers Die folgenden wichtigen Punkte werden durch den Beispiel-Test-Harness hervorgehoben. XML-MORE-BUFFER initialisieren Das Feld XML-MORE-BUFFER zeigt an, ob weitere aus dem Puffer zu lesende Daten vorhanden sind. Bevor der Reader das erste Mal aufgerufen wird, sollte dieses Feld auf "F" (First) gesetzt werden.
162 Lernprogramme
XML Thunder
Programmzeile im generierten Beispiel-Test-Harness zum Einstellen von XML-MORE-BUFFER XML-BUFFER fllen Bei einem XML-Reader auf Knoten-Ebene braucht nicht das gesamte Dokument mit einem Aufruf des Handlers verarbeitet zu werden. Stattdessen kann das Dokument in Segmente aufgeteilt werden, die dem Handler in wiederholten Aufrufen bergeben werden. Nehmen wir zum Beispiel an, Sie htten aus praktischen Grnden einen XML-Reader auf KnotenEbene mit einer Puffergre von 5000 Zeichen definiert. Das bedeutet, dass der Handler bei jedem Aufruf bis zu 5000 Zeichen eines XML-Dokuments lesen kann. Nehmen wir auerdem an, dass der Handler verwendet wird, um ein XML-Dokument zu verarbeiten, dass 9000 Zeichen lang ist. Das folgende Beispiel zeigt, wie solch ein Dokument verarbeitet werden knnte:
Beispiel-Code im Test Harness zum Fllen der IDS eines XML-Readers Das aufrufende Programm verschiebt die ersten 5000 Zeichen des XML-Dokuments in das Feld XML-BUFFER und reicht es an den Handler weiter. Alle nicht vom Reader verarbeiteten Zeichen werden an den Anfang des Puffers geschoben, bevor die Steuerung an den Test Harness zurckgegeben wird. Der Test Harness fllt den Puffer dann wieder auf, indem er einen weiteren Teil des XML-Dokuments an ihn anhngt. Dann wird der XML-Reader wieder aufgerufen und der Vorgang wird wiederholt, bis das gesamte Dokument gelesen wurde. Aufrufen des XML-Handlers
XML Thunder
Lernprogramme 163
Der eigentliche Aufruf eines XML-Readers auf Knoten-Ebene, wie er im Test Harness generiert wird, ist unten gezeigt:
Generierter Beispiel-Code im Test Harness zum Aufrufen eines XML-Readers Nach jedem Aufruf des Handlers sollte der Puffer wieder gefllt werden - auf Grundlage der Regeln in Schritt 2 - und der XML-Handler sollte wieder aufgerufen werden, bis das gesamte XMLDokument verarbeitet ist. Wenn das XML-Dokument vollstndig gelesen wurde, wird der XMLMORE-BUFFER auf "L" gesetzt und XML-RETURN-CODE auf "OK". Schritt 6 - Fhren Sie das Testprogramm aus Der von XML Thunder generierte Test Harness ist ein eigenstndiges Programm, das verwendet werden kann, um den XML-Handler auszufhren. Beispieldaten werden in-line generiert und die Ergebnisse werden auf der Konsole angezeigt. Beachten Sie, dass Sie den Test Harness so einstellen knnen, dass die Ausgabe in eine Datei geschrieben wird. ndern Sie dazu seine GenerierungsEinstellungen unter "More Options". Eine schrittweise Verfolgung der Ausgabedaten ermglicht weitere Einsichten darber, wie XML-Dokumente unter Verwendung von Handlern auf KnotenEbene gelesen und geschrieben werden.
Support
Technischer Support
Bitte kontaktieren Sie Canam Software ber: Telefon 1-888-432-2626 (9 a.m. 5 p.m. ET North America)
164 Support XML Thunder
1-905-712-3840 Fax: 1-905-712 0043
E-Mail: support@canamsoftware.com
Bestellmglichkeiten
So bestellen Sie XML Thunder

Sie knnen XML Thunder auf verschiedenen Wegen bestellen: Canam Software Labs, Inc. E-Mail: sales@canamsoftware.com Telefon 1-888-432-2626 1-905-712-3840 Fax: 1-905-712-0043
Lokaler Vertragshndler fr Canam Software Labs, Inc Bitte wenden Sie sich an Ihren lokalen Hndler fr Canam Software-Produkte
XML Thunder
Bestellmglichkeiten 165

XT v4 User Manual German

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

XT v4 User Manual German

Hochgeladen von

Copyright:

Verfügbare Formate

Dieses Handbuch wurde von Canam Software Labs, Inc. herausgegeben.

Neue Features in XML Thunder Version 4

Erweiterungen des Entwicklungs-Toolsets ................................................................................ 9 nderungen in der Code-Generierung ....................................................................................... 9

Schnellstart: Erstellen eines XML-Handlers

Der New-Handler-Assistent von XML Thunder

Der XML Thunder Designer

Technischer Support .............................................................................................................. 164

So bestellen Sie XML Thunder .............................................................................................. 165

Neue Features in XML Thunder Version 4

Erweiterungen des Entwicklungs-Toolsets

nderungen in der Code-Generierung

10 Neue Features in XML Thunder Version 4

Schnellstart: Erstellen eines XMLHandlers

Starten Sie den Assistenten zum Erstellen eines neuen Handlers

Whlen Sie die Quelle fr die XML- und Programm-DatenfeldStrukturen aus

Schnellstart: Erstellen eines XML-Handlers 11

Legen Sie die Eigenschaften des XML-Handlers fest

12 Schnellstart: Erstellen eines XML-Handlers

Generieren der Handler

Registerkarte "XML-Reader Generation"

Registerkarte "XML-Writer Generation"

14 Schnellstart: Erstellen eines XML-Handlers

Quellcode des XML-Writers

Schnellstart: Erstellen eines XML-Handlers 15

Testen der XML-Handler

Testen des XML-Writers:

16 Schnellstart: Erstellen eines XML-Handlers

Der New-Handler-Assistent von XML Thunder

Starten des Assistenten

Auswhlen der Quelle

Entwerfen der IDS

18 Der New-Handler-Assistent von XML Thunder

Der New-Handler-Assistent von XML Thunder 19

20 Der New-Handler-Assistent von XML Thunder

Der XML Thunder Designer

Der XML Thunder Designer 21

Registerkarte Logical IDS

22 Der XML Thunder Designer

Registerkarte Physical IDS

Der XML Thunder Designer 23

24 Der XML Thunder Designer

Der XML Thunder Designer 25

26 Der XML Thunder Designer

Der XML Thunder Designer 27

Aus- und Einklappen von Listenknoten

28 Der XML Thunder Designer

XML-ALL-Struktur XML Thunder Spezialfeld

Add (XML Item)

Add P.I. (Processing Instruction) Node

30 Der XML Thunder Designer

Add DOCTYPE Node

Add Comment Node

Add Element Node

Add Attribute Node

Add All Node

Add Choice Node

Add Sequence Node

Der XML Thunder Designer 31

Undo- und Redo-Funktionen

Aus- und Einklappen von Listenknoten

Tools -> Import WSDL

Tools -> Import XML Sample

Tools -> Import XML Handler

XML Schema Validation