source: icXML/icXML-devel/samples/src/PSVIWriter/PSVIWriterHandlers.cpp @ 2733

Last change on this file since 2733 was 2733, checked in by cameron, 6 years ago

More path fixes.

File size: 74.3 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18// ---------------------------------------------------------------------------
19//  Includes
20// ---------------------------------------------------------------------------
21#include "PSVIWriterHandlers.hpp"
22#include <xercesc/util/PSVIUni.hpp>
23#include <xercesc/util/XMLUni.hpp>
24#include <xercesc/util/XMLUniDefs.hpp>
25#include <icxercesc/util/XMLString.hpp>
26#include <xercesc/sax/SAXParseException.hpp>
27#include <xercesc/sax/SAXException.hpp>
28#include <xercesc/dom/DOMAttr.hpp>
29#include <xercesc/dom/DOMDocument.hpp>
30#include <xercesc/dom/DOMNode.hpp>
31#include <xercesc/dom/DOMNodeList.hpp>
32#include <xercesc/dom/DOMTypeInfo.hpp>
33#include <xercesc/dom/DOMImplementationRegistry.hpp>
34#include <xercesc/dom/DOMImplementation.hpp>
35#include <xercesc/framework/psvi/XSValue.hpp>
36
37#include <string.h>
38#include <stdio.h>
39
40XERCES_CPP_NAMESPACE_USE
41
42static const XMLCh fgSpace[] = { chSpace, chNull };
43static const XMLCh fgRoot[] = { chLatin_r, chLatin_o, chLatin_o, chLatin_t, chNull };
44static const XMLCh fgChar[] = { chSpace, chLatin_C, chLatin_h, chLatin_a, chLatin_r, chNull }; // char
45static const XMLCh fgLine[] = { chSpace, chLatin_L, chLatin_i, chLatin_n, chLatin_e, chNull }; // line
46static const XMLCh fgError[] = { chLatin_E, chLatin_r, chLatin_r, chLatin_o, chLatin_r, chNull }; //Error
47static const XMLCh fgAtFile[] = { // at file
48        chSpace, chLatin_a, chLatin_t, chSpace, chLatin_f, chLatin_i, chLatin_l, chLatin_e, chNull
49};
50static const XMLCh fgFatalError[] = { //Fatal Error
51        chLatin_F, chLatin_a, chLatin_t, chLatin_a, chLatin_l, chSpace,
52        chLatin_E, chLatin_r, chLatin_r, chLatin_o, chLatin_r, chNull
53};
54static const XMLCh fgMessage[] = { //Message
55        chLatin_M, chLatin_e, chLatin_s, chLatin_s, chLatin_a, chLatin_g, chLatin_e, chNull
56};
57static const XMLCh fgXsiNil[] = { //xsi:nil
58        chLatin_x, chLatin_s, chLatin_i, chColon, chLatin_n, chLatin_i, chLatin_l, chNull
59};
60static const XMLCh fgWarning[] = { //Warning
61        chLatin_W, chLatin_a, chLatin_r, chLatin_n, chLatin_i, chLatin_n, chLatin_g, chNull
62};
63static const XMLCh gXmlnsColonXsi[] = { //xmlns:xsi
64        chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chColon, chLatin_x, chLatin_s,
65        chLatin_i, chNull
66};
67static const XMLCh gXmlnsColonPsv[] = { //xmlns:psv
68        chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chColon, chLatin_p, chLatin_s,
69        chLatin_v, chNull
70};
71
72static const XMLCh gRef[] = { chLatin_r, chLatin_e, chLatin_f, chNull }; // ref
73static const XMLCh gId[] = { chLatin_i, chLatin_d, chNull }; // id
74
75static const XMLCh gEqualsQuote[] = { chEqual, chDoubleQuote, chNull };
76static const XMLCh gAngleSlash[] = { chOpenAngle, chForwardSlash, chNull };
77static const XMLCh gAngleFeed[] = { chCloseAngle, chLF, chNull };
78static const XMLCh gSlashAngleFeed[] = { chForwardSlash, chCloseAngle, chLF, chNull };
79static const XMLCh gQuoteAngleFeed[] = { chDoubleQuote, chCloseAngle, chLF, chNull };
80
81static const XMLCh gActualValue[] = { chLatin_a, chLatin_c, chLatin_t, chLatin_u, chLatin_a,
82                                      chLatin_l, chLatin_V, chLatin_a, chLatin_l, chLatin_u,
83                                      chLatin_e, chNull };
84
85static const XMLCh gDataType[] = { chLatin_d, chLatin_a, chLatin_t, chLatin_a, chLatin_T,
86                                   chLatin_y, chLatin_p, chLatin_e, chNull };
87static const XMLCh gDataValue[] = { chLatin_d, chLatin_a, chLatin_t, chLatin_a, chLatin_V,
88                                   chLatin_a, chLatin_l,  chLatin_u, chLatin_e, chNull };
89static const XMLCh gCommentStart[] = { chOpenAngle, chBang, chDash, chDash, chLF, chNull};
90static const XMLCh gCommentEnd[] = { chDash, chDash, chCloseAngle, chLF, chNull};
91
92static const XMLCh gPartialElementPSVI[] =
93{ chLatin_p, chLatin_a, chLatin_r, chLatin_t, chLatin_i, chLatin_t, chLatin_i, chLatin_a, chLatin_l,
94  chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t,
95  chLatin_P, chLatin_S, chLatin_V, chLatin_I, chNull };
96
97// ---------------------------------------------------------------------------
98//  PSVIWriterHandlers: Constructors and Destructor
99// ---------------------------------------------------------------------------
100PSVIWriterHandlers::PSVIWriterHandlers(XMLFormatter* outputFormatter, XMLFormatter* errorFormatter) :
101                PSVIHandler(), DefaultHandler() {
102        fFormatter = outputFormatter;
103        fErrorFormatter = (errorFormatter != NULL) ? errorFormatter : outputFormatter;
104
105        fAttrList = new StringList(8, false);
106        fTempResult = new XMLCh[51];
107    fIndentChars = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate(101*sizeof(XMLCh));
108        fBaseUri = 0;
109
110        XMLString::copyString(fIndentChars, XMLUni::fgZeroLenString);
111
112        fIndent = 0;
113        fIndentCap = 100;
114        fAnonNum = 1000;
115
116        fIdMap = new RefHashTableOf<XMLCh>(101, false);
117        fDefinedIds = new RefVectorOf<XSObject>(25, false);
118        fIdNames = new RefArrayVectorOf<XMLCh>(25, true);
119        fObjectLocations = new RefArrayVectorOf<XMLCh>(25, true);
120
121        fPrefixMap = new RefHashTableOf<XMLCh>(5, false);
122        fNamespaces = new RefArrayVectorOf<XMLCh>(5, false);
123
124        fNSAttributes = new ValueVectorOf<XMLSize_t>(15);
125        fElementChildren = new ValueStackOf<bool>(20);
126
127
128        fAttributesInfo = new RefVectorOf<AttrInfo>(8, true);
129}
130
131PSVIWriterHandlers::~PSVIWriterHandlers() {
132        if (fBaseUri != NULL)
133                XMLString::release(&fBaseUri);
134        delete fAttrList;
135        delete[] fTempResult;
136        XMLPlatformUtils::fgMemoryManager->deallocate(fIndentChars);
137
138        delete fIdMap;
139        delete fDefinedIds;
140        delete fIdNames;
141        delete fObjectLocations;
142
143        delete fPrefixMap;
144        delete fNamespaces;
145
146        delete fNSAttributes;
147        delete fElementChildren;
148
149        delete fAttributesInfo;
150
151}
152
153// -----------------------------------------------------------------------
154//  Convenience Utility
155// -----------------------------------------------------------------------
156
157void PSVIWriterHandlers::resetPSVIFormatter(XMLFormatter* outputFormatter) {
158        fFormatter = outputFormatter;
159}
160
161void PSVIWriterHandlers::resetDocument() {
162
163        fIndent = 0;
164        fAnonNum = 1000;
165        XMLString::copyString(fIndentChars, XMLUni::fgZeroLenString);
166
167        if (fBaseUri != NULL)
168                XMLString::release(&fBaseUri);
169
170        fIdMap->removeAll();
171        fDefinedIds->removeAllElements();
172        fIdNames->removeAllElements();
173        fObjectLocations->removeAllElements();
174
175        fPrefixMap->removeAll();
176        fNamespaces->removeAllElements();
177
178        fElementChildren->removeAllElements();
179}
180
181// ---------------------------------------------------------------------------
182//  PSVIWriterHandlers: Implementation of the SAX DocumentHandler interface
183// ---------------------------------------------------------------------------
184void PSVIWriterHandlers::startElement(  const XMLCh* const /* uri */,
185                                                                                const XMLCh* const /* localname */,
186                                                                                const XMLCh* const /* qname */,
187                                                                                const Attributes& attrs) {
188        fAttributesInfo->removeAllElements();
189        for (XMLSize_t i=0; i<attrs.getLength(); i++) {
190                fAttributesInfo->addElement(
191                        new AttrInfo(
192                                attrs.getURI(i),
193                                attrs.getLocalName(i),
194                                attrs.getType(i),
195                                attrs.getValue(i)
196                        )
197                );
198        }
199}
200
201void PSVIWriterHandlers::endElement(    const XMLCh* const /* uri */,
202                                                                                const XMLCh* const /* localname */,
203                                                                                const XMLCh* const /* qname */) {
204}
205
206void PSVIWriterHandlers::startDocument() {
207        fAttrList->removeAllElements();
208        fAttrList->addElement((XMLCh*)gXmlnsColonXsi);
209        fAttrList->addElement((XMLCh*)PSVIUni::fgNamespaceInstance);
210        fAttrList->addElement((XMLCh*)gXmlnsColonPsv);
211        fAttrList->addElement((XMLCh*)PSVIUni::fgNamespacePsvi);
212        fAttrList->addElement((XMLCh*)XMLUni::fgXMLNSString);
213        fAttrList->addElement((XMLCh*)PSVIUni::fgNamespaceInfoset);
214
215        writeOpen(PSVIUni::fgDocument, fAttrList);
216        incIndent();
217        fElementChildren->push(false);
218}
219
220void PSVIWriterHandlers::endDocument() {
221        processChildrenEnd();
222        sendElementEmpty(PSVIUni::fgDocumentElement);
223        writeEmpty(PSVIUni::fgNotations);
224        writeEmpty(PSVIUni::fgUnparsedEntities);
225        sendElementValue(PSVIUni::fgBaseURI, fBaseUri);
226        sendElementValue(PSVIUni::fgAllDeclarationsProcessed, PSVIUni::fgTrue);
227        sendUnindentedElement(PSVIUni::fgDocument);
228        resetDocument();
229}
230
231void PSVIWriterHandlers::characters(    const XMLCh* const chars,
232                                                                        const XMLSize_t /* length */ ) {
233        processChildren();
234        sendIndentedElement(PSVIUni::fgCharacter);
235        sendElementValue(PSVIUni::fgTextContent, chars);
236        sendUnindentedElement(PSVIUni::fgCharacter);
237}
238
239void PSVIWriterHandlers::ignorableWhitespace(   const XMLCh* const /* chars */,
240                                                                                                const XMLSize_t    /* length */) {
241        //ignore it
242}
243
244void PSVIWriterHandlers::comment(const XMLCh* const chars, const XMLSize_t /* length */) {
245        processChildren();
246        sendIndentedElement(PSVIUni::fgComment);
247        sendElementValue(PSVIUni::fgContent, chars);
248        sendUnindentedElement(PSVIUni::fgComment);
249}
250
251void PSVIWriterHandlers::processingInstruction( const XMLCh* const target,
252                                                                                                const XMLCh* const data) {
253        processChildren();
254        sendIndentedElement(PSVIUni::fgProcessingInstruction);
255        sendElementValue(PSVIUni::fgTarget, target);
256        sendElementValue(PSVIUni::fgContent, data);
257        sendUnindentedElement(PSVIUni::fgProcessingInstruction);
258}
259
260void PSVIWriterHandlers::startPrefixMapping(const XMLCh* const prefix, const XMLCh* const uri) {
261        if (!fPrefixMap->containsKey(uri)) {
262                XMLCh* permaUri = XMLString::replicate((XMLCh*)uri);
263                XMLCh* permaPrefix = XMLString::replicate((XMLCh*)prefix);
264                fNamespaces->addElement(permaUri);
265                fPrefixMap->put(permaUri, permaPrefix);
266        }
267}
268
269void PSVIWriterHandlers::endPrefixMapping(const XMLCh* const prefix) {
270        for (unsigned int i=0; i < fNamespaces->size(); i++) {
271                if (XMLString::equals(fPrefixMap->get(fNamespaces->elementAt(i)), prefix)) {
272                        XMLCh* uri = fNamespaces->elementAt(i);
273                        XMLCh* pre = fPrefixMap->get(uri);
274                        fPrefixMap->removeKey(uri);
275                        fNamespaces->removeElementAt(i);
276                        XMLString::release(&uri);
277                        XMLString::release(&pre);
278                        break;
279                }
280        }
281}
282
283InputSource* PSVIWriterHandlers::resolveEntity(XMLResourceIdentifier* resourceIdentifier) {
284        if (fBaseUri != NULL)
285                XMLString::release(&fBaseUri);
286        fBaseUri = XMLString::replicate(resourceIdentifier->getBaseURI());
287        return 0;
288}
289
290InputSource* PSVIWriterHandlers::resolveEntity(const XMLCh* const, const XMLCh* const) {
291    return 0;
292}
293
294// ---------------------------------------------------------------------------
295//  PSVIWriterHandlers: Overrides of the SAX ErrorHandler interface
296// ---------------------------------------------------------------------------
297void PSVIWriterHandlers::error(const SAXParseException& e) {
298        XMLCh* temp1 = new XMLCh[10];
299        XMLCh* temp2 = new XMLCh[10];
300        XMLString::binToText((unsigned long)e.getLineNumber(), temp1, 9, 10);
301        XMLString::binToText((unsigned long)e.getColumnNumber(), temp2, 9, 10);
302        *fErrorFormatter << fgError << fgAtFile << chSpace << e.getSystemId()
303                << chComma << fgLine << chSpace << temp1
304                << chComma << fgChar << chSpace << temp2
305                << chLF << fgMessage << chColon << e.getMessage() << chLF;
306        delete[] temp1;
307        delete[] temp2;
308}
309
310void PSVIWriterHandlers::fatalError(const SAXParseException& e) {
311        XMLCh* temp1 = new XMLCh[10];
312        XMLCh* temp2 = new XMLCh[10];
313        XMLString::binToText((unsigned long)e.getLineNumber(), temp1, 9, 10);
314        XMLString::binToText((unsigned long)e.getColumnNumber(), temp2, 9, 10);
315        *fErrorFormatter << fgFatalError << fgAtFile << chSpace << e.getSystemId()
316                << chComma << fgLine << chSpace << temp1
317                << chComma << fgChar << chSpace << temp2
318                << chLF << fgMessage << chColon << e.getMessage() << chLF;
319        delete[] temp1;
320        delete[] temp2;
321        resetDocument();
322}
323
324void PSVIWriterHandlers::warning(const SAXParseException& e) {
325        XMLCh* temp1 = new XMLCh[10];
326        XMLCh* temp2 = new XMLCh[10];
327        XMLString::binToText((unsigned long)e.getLineNumber(), temp1, 9, 10);
328        XMLString::binToText((unsigned long)e.getColumnNumber(), temp2, 9, 10);
329        *fErrorFormatter << fgWarning << fgAtFile << chSpace << e.getSystemId()
330                << chComma << fgLine << chSpace << temp1
331                << chComma << fgChar << chSpace << temp2
332                << chLF << fgMessage << chColon << e.getMessage() << chLF;
333        delete[] temp1;
334        delete[] temp2;
335}
336
337void PSVIWriterHandlers::resetErrors()
338{
339}
340
341// ---------------------------------------------------------------------------
342//  PSVIWriterHandlers: Overrides of the PSVIHandler interface
343// ---------------------------------------------------------------------------
344
345void PSVIWriterHandlers::handleAttributesPSVI(  const XMLCh* const localName,
346                                                                                                const XMLCh* const uri,
347                                                                                                PSVIAttributeList* psviAttributes ) {
348
349        processChildren();
350        fElementChildren->push(false);
351        sendIndentedElement(PSVIUni::fgElement);
352        sendElementValue(PSVIUni::fgNamespaceName, uri);
353        sendElementValue(PSVIUni::fgLocalName, localName);
354        sendElementValue(PSVIUni::fgPrefix, fPrefixMap->get(uri));
355        processAttributes(psviAttributes, fAttributesInfo);
356        processInScopeNamespaces();
357        sendElementValue(PSVIUni::fgBaseURI, fBaseUri);
358}
359
360void PSVIWriterHandlers::handleElementPSVI(     const XMLCh* const /* localName */,
361                                                                                        const XMLCh* const /* uri */,
362                                                                                        PSVIElement* elementInfo ) {
363
364    processActualValue(elementInfo);
365        processChildrenEnd();
366        processSchemaInformation(elementInfo->getSchemaInformation());
367        sendElementValue( PSVIUni::fgValidationAttempted,
368                translateValidationAttempted(elementInfo->getValidationAttempted()));
369        sendElementValue(PSVIUni::fgValidationContext, elementInfo->getValidationContext());
370        sendElementValue(PSVIUni::fgValidity, translateValidity(elementInfo->getValidity()));
371        //REVISIT errorCodes not supported
372        //processSchemaErrorCode(elementInfo->getErrorCodes());
373        sendElementEmpty(PSVIUni::fgSchemaErrorCode);
374        sendElementValue(PSVIUni::fgSchemaNormalizedValue, elementInfo->getSchemaNormalizedValue());
375        sendElementValue(PSVIUni::fgCanonicalRepresentation, elementInfo->getCanonicalRepresentation());
376        sendElementValue(PSVIUni::fgSchemaSpecified,
377                (elementInfo->getIsSchemaSpecified() ? PSVIUni::fgSchema : PSVIUni::fgInfoset));
378        sendElementValue(PSVIUni::fgSchemaDefault, elementInfo->getSchemaDefault());
379        processTypeDefinitionRef(PSVIUni::fgTypeDefinition, elementInfo->getTypeDefinition());
380        processTypeDefinitionRef(PSVIUni::fgMemberTypeDefinition, elementInfo->getMemberTypeDefinition());
381        sendElementEmpty(PSVIUni::fgNil);
382        processElementDeclarationRef(PSVIUni::fgDeclaration, elementInfo->getElementDeclaration());
383        sendReference(PSVIUni::fgNotation, elementInfo->getNotationDeclaration());
384        sendElementEmpty(PSVIUni::fgIdIdrefTable);
385        sendElementEmpty(PSVIUni::fgIdentityConstraintTable);
386        sendUnindentedElement(PSVIUni::fgElement);
387
388}
389
390/***
391 *
392 *  <partialElementPSVI>
393 *        getValidity()
394 *        getValidationAttemped()
395 *        getValidationContext()
396 *        getIsSchemaSpecified()
397 *        getElementDeclaration()
398 *        getTypeDefinition()
399 *        getMemberTypeDefinition()
400 *        getSchemaInformation()
401 *        getSchemaDefault()
402 *        getSchemaNormalizedValue()
403 *        getCanonicalRepresentation()
404 *        getNotationDeclaration()
405 *  </partialElementPSVI>
406 *
407 ***/
408void
409PSVIWriterHandlers::handlePartialElementPSVI( const XMLCh*       const /* localName */,
410                                              const XMLCh*       const /* uri */,
411                                                    PSVIElement*       elementInfo )
412{
413
414    writeString(gCommentStart);
415    incIndent();
416    writeOpen(gPartialElementPSVI);
417    incIndent();
418
419        processSchemaInformation(elementInfo->getSchemaInformation());
420        sendElementValue(PSVIUni::fgValidationAttempted
421                   , translateValidationAttempted(elementInfo->getValidationAttempted()));
422        sendElementValue(PSVIUni::fgValidationContext
423                   , elementInfo->getValidationContext());
424    sendElementValue(PSVIUni::fgValidity
425                   , translateValidity(elementInfo->getValidity()));
426        sendElementValue(PSVIUni::fgSchemaNormalizedValue
427                   , elementInfo->getSchemaNormalizedValue());
428        sendElementValue(PSVIUni::fgCanonicalRepresentation
429                   , elementInfo->getCanonicalRepresentation());
430        sendElementValue(PSVIUni::fgSchemaSpecified
431                  , (elementInfo->getIsSchemaSpecified() ? PSVIUni::fgSchema : PSVIUni::fgInfoset));
432    sendElementValue(PSVIUni::fgSchemaDefault
433                   , elementInfo->getSchemaDefault());
434    processTypeDefinitionRef(PSVIUni::fgTypeDefinition
435                           , elementInfo->getTypeDefinition());
436        processTypeDefinitionRef(PSVIUni::fgMemberTypeDefinition
437                           , elementInfo->getMemberTypeDefinition());
438    processElementDeclarationRef(PSVIUni::fgDeclaration
439                               , elementInfo->getElementDeclaration());
440    sendReference(PSVIUni::fgNotation
441                , elementInfo->getNotationDeclaration());
442
443    decIndent();
444    writeClose(gPartialElementPSVI);
445    decIndent();
446    writeString(gCommentEnd);
447
448}
449
450// ---------------------------------------------------------------------------
451//  Private methods
452// ---------------------------------------------------------------------------
453
454void PSVIWriterHandlers::processAttributes(PSVIAttributeList* psviAttributes, const RefVectorOf<AttrInfo>* attributesInfo) {
455        fNSAttributes->removeAllElements();  //will store the indecies of namespace attributes
456        bool firstFlag = true;
457        for (XMLSize_t i = 0; i < attributesInfo->size(); i++) {
458                if (attributesInfo->elementAt(i)->getUri() == XMLUni::fgXMLNSURIName) {
459                        fNSAttributes->addElement(i);
460                } else {
461                        if (firstFlag) {
462                                sendIndentedElement(PSVIUni::fgAttributes);
463                                firstFlag = false;
464                        }
465                        const XMLCh* localName = attributesInfo->elementAt(i)->getLocalName();
466                        const XMLCh* namespaceUri = attributesInfo->elementAt(i)->getUri();
467                        sendIndentedElement(PSVIUni::fgAttribute);
468                        sendElementValue(PSVIUni::fgNamespaceName, namespaceUri);
469                        sendElementValue(PSVIUni::fgLocalName, localName);
470                        sendElementValue(PSVIUni::fgPrefix, fPrefixMap->get(attributesInfo->elementAt(i)->getUri()));
471                        sendElementValue(PSVIUni::fgNormalizedValue, attributesInfo->elementAt(i)->getValue());
472                        if (psviAttributes!=NULL && psviAttributes->getAttributePSVIAtIndex(i)!=NULL) {
473                                sendElementValue(PSVIUni::fgSpecified,
474                                        translateBool(!(psviAttributes->getAttributePSVIAtIndex(i)->getIsSchemaSpecified())));
475                        } else //the desired value is !schemaSpecified
476                                sendElementValue(PSVIUni::fgSpecified, PSVIUni::fgUnknown);
477                        sendElementValue(PSVIUni::fgAttributeType, attributesInfo->elementAt(i)->getType());
478                        sendElementEmpty(PSVIUni::fgReferences);
479                        PSVIAttribute* psviAttr = psviAttributes->getAttributePSVIByName(localName, namespaceUri);
480                        processAttributePSVI(psviAttr);
481                        sendUnindentedElement(PSVIUni::fgAttribute);
482                }
483        }
484        if (firstFlag)
485                writeEmpty(PSVIUni::fgAttributes);
486        else
487                sendUnindentedElement(PSVIUni::fgAttributes);
488        processNamespaceAttributes(psviAttributes, attributesInfo);
489}
490
491void PSVIWriterHandlers::processNamespaceAttributes(PSVIAttributeList* psviAttributes, const RefVectorOf<AttrInfo>* attributes) {
492        if (fNSAttributes->size()==0) {
493                writeEmpty(PSVIUni::fgNamespaceAttributes);
494        } else {
495                sendIndentedElement(PSVIUni::fgNamespaceAttributes);
496                XMLSize_t ind;
497                for (XMLSize_t count = 0; count < fNSAttributes->size(); count++) {
498                        ind = fNSAttributes->elementAt(count);
499                        sendIndentedElement(PSVIUni::fgAttribute);
500                        sendElementValue(PSVIUni::fgNamespaceName, XMLUni::fgXMLNSURIName);
501                        sendElementValue(PSVIUni::fgLocalName, attributes->elementAt(ind)->getLocalName());
502                        sendElementValue(PSVIUni::fgPrefix, XMLUni::fgXMLNSString);
503                        sendElementValue(PSVIUni::fgNormalizedValue, attributes->elementAt(ind)->getValue());
504                        if (psviAttributes!=NULL) {
505                                sendElementValue(PSVIUni::fgSpecified,
506                                        translateBool(
507                                                psviAttributes->getAttributePSVIByName(
508                                                        attributes->elementAt(ind)->getLocalName(),
509                                                        attributes->elementAt(ind)->getUri()
510                                                )->getIsSchemaSpecified()
511                                        )
512                                );
513                        } else
514                                sendElementValue(PSVIUni::fgSpecified, PSVIUni::fgUnknown);
515                        sendElementValue(PSVIUni::fgAttributeType, attributes->elementAt(ind)->getType());
516                        // this property isn't relevent to PSVI
517                        sendElementEmpty(PSVIUni::fgReferences);
518                        sendUnindentedElement(PSVIUni::fgAttribute);
519                }
520                sendUnindentedElement(PSVIUni::fgNamespaceAttributes);
521        }
522}
523
524void PSVIWriterHandlers::processAttributePSVI(PSVIAttribute* attrPSVI) {
525        if (attrPSVI != NULL) {
526                sendElementValue(PSVIUni::fgValidationAttempted,
527                        translateValidationAttempted(attrPSVI->getValidationAttempted()));
528                sendElementValue(PSVIUni::fgValidationContext, attrPSVI->getValidationContext());
529                sendElementValue(PSVIUni::fgValidity, translateValidity(attrPSVI->getValidity()));
530                //REVISIT errorCodes not supported
531                //processSchemaErrorCode(attrPSVI->getErrorCodes());
532                sendElementEmpty(PSVIUni::fgSchemaErrorCode);
533                sendElementValue(PSVIUni::fgSchemaNormalizedValue, attrPSVI->getSchemaNormalizedValue());
534                sendElementValue(PSVIUni::fgSchemaSpecified,
535                        (attrPSVI->getIsSchemaSpecified() ? PSVIUni::fgSchema : PSVIUni::fgInfoset));
536                sendElementValue(PSVIUni::fgSchemaDefault, attrPSVI->getSchemaDefault());
537                processTypeDefinitionRef(PSVIUni::fgTypeDefinition, attrPSVI->getTypeDefinition());
538                processTypeDefinitionOrRef(PSVIUni::fgMemberTypeDefinition, attrPSVI->getMemberTypeDefinition());
539                processAttributeDeclarationRef(PSVIUni::fgDeclaration, attrPSVI->getAttributeDeclaration());
540
541        processActualValue(attrPSVI);
542        }
543}
544
545void PSVIWriterHandlers::processInScopeNamespaces() {
546        sendIndentedElement(PSVIUni::fgInScopeNamespaces);
547        sendIndentedElement(PSVIUni::fgNamespace);
548        sendElementValue(PSVIUni::fgPrefix, PSVIUni::fgXml);
549        sendElementValue(PSVIUni::fgNamespaceName, XMLUni::fgXMLURIName);
550        sendUnindentedElement(PSVIUni::fgNamespace);
551        for (unsigned int i=0; i<fNamespaces->size(); i++) {
552                sendIndentedElement(PSVIUni::fgNamespace);
553                sendElementValue(PSVIUni::fgPrefix, fPrefixMap->get(fNamespaces->elementAt(i)));
554                sendElementValue(PSVIUni::fgNamespaceName, fNamespaces->elementAt(i));
555                sendUnindentedElement(PSVIUni::fgNamespace);
556        }
557        sendUnindentedElement(PSVIUni::fgInScopeNamespaces);
558}
559
560void PSVIWriterHandlers::processSchemaInformation(XSModel* model) {
561        if (fElementChildren->size()!=1 || model==NULL) {
562                sendElementEmpty(PSVIUni::fgSchemaInformation);
563        } else {
564                sendIndentedElement(PSVIUni::fgSchemaInformation);
565                XSNamespaceItemList* namespaceItems = model->getNamespaceItems();
566                for (unsigned int i=0; i < namespaceItems->size(); i++) {
567                        processNamespaceItem(namespaceItems->elementAt(i));
568                }
569                sendUnindentedElement(PSVIUni::fgSchemaInformation);
570        }
571}
572
573void PSVIWriterHandlers::processNamespaceItem(XSNamespaceItem* namespaceItem) {
574        if (!XMLString::equals(namespaceItem->getSchemaNamespace(), PSVIUni::fgNamespaceXmlSchema)) {
575                sendIndentedElement(PSVIUni::fgNamespaceSchemaInformation);
576                sendElementValue(PSVIUni::fgSchemaNamespace, namespaceItem->getSchemaNamespace());
577                processSchemaComponents(namespaceItem);
578                processSchemaDocuments(namespaceItem);
579                processSchemaAnnotations(namespaceItem->getAnnotations());
580                sendUnindentedElement(PSVIUni::fgNamespaceSchemaInformation);
581        }
582}
583
584void PSVIWriterHandlers::processSchemaComponents(XSNamespaceItem* namespaceItem) {
585        sendIndentedElement(PSVIUni::fgSchemaComponents);
586        XSNamedMap<XSTypeDefinition>* types = (XSNamedMap<XSTypeDefinition>*)(namespaceItem->getComponents(XSConstants::TYPE_DEFINITION));
587        for (XMLSize_t typeCount = 0; typeCount < types->getLength(); typeCount++) {
588                processTypeDefinition(types->item(typeCount));
589        }
590        XSNamedMap<XSAttributeDeclaration>* attributes = (XSNamedMap<XSAttributeDeclaration>*)namespaceItem->getComponents(XSConstants::ATTRIBUTE_DECLARATION);
591        for (XMLSize_t attrCount = 0; attrCount < attributes->getLength(); attrCount++) {
592                processAttributeDeclaration(attributes->item(attrCount));
593        }
594        XSNamedMap<XSElementDeclaration>* elements = (XSNamedMap<XSElementDeclaration>*)namespaceItem->getComponents(XSConstants::ELEMENT_DECLARATION);
595        for (XMLSize_t elemCount = 0; elemCount < elements->getLength(); elemCount++) {
596                processElementDeclaration(elements->item(elemCount));
597        }
598        XSNamedMap<XSAttributeGroupDefinition>* attrGroups = (XSNamedMap<XSAttributeGroupDefinition>*)namespaceItem->getComponents(XSConstants::ATTRIBUTE_GROUP_DEFINITION);
599        for (XMLSize_t attrGroupCount = 0; attrGroupCount < attrGroups->getLength(); attrGroupCount++) {
600                processAttributeGroupDefinition(attrGroups->item(attrGroupCount));
601        }
602        XSNamedMap<XSModelGroupDefinition>* modelGroups = (XSNamedMap<XSModelGroupDefinition>*)namespaceItem->getComponents(XSConstants::MODEL_GROUP_DEFINITION);
603        for (XMLSize_t modelGroupCount = 0; modelGroupCount < modelGroups->getLength(); modelGroupCount++) {
604                processModelGroupDefinition(modelGroups->item(modelGroupCount));
605        }
606        XSNamedMap<XSNotationDeclaration>* notations = (XSNamedMap<XSNotationDeclaration>*)namespaceItem->getComponents(XSConstants::NOTATION_DECLARATION);
607        for (XMLSize_t notationCount = 0; notationCount < notations->getLength(); notationCount++) {
608                processNotationDeclaration(notations->item(notationCount));
609        }
610        sendUnindentedElement(PSVIUni::fgSchemaComponents);
611}
612
613void PSVIWriterHandlers::processSchemaDocuments(XSNamespaceItem* namespaceItem) {
614        const StringList* locations = namespaceItem->getDocumentLocations();
615        if (locations==NULL) {
616                sendElementEmpty(PSVIUni::fgSchemaDocuments);
617        }
618        sendIndentedElement(PSVIUni::fgSchemaDocuments);
619        for (unsigned int i = 0; i < locations->size(); i++) {
620                sendIndentedElement(PSVIUni::fgSchemaDocument);
621                sendElementValue(PSVIUni::fgDocumentLocation, locations->elementAt(i));
622                sendElementEmpty(PSVIUni::fgPsvDocument); //supposed to point to a document element, but we dont deal with them
623                sendUnindentedElement(PSVIUni::fgSchemaDocument);
624        }
625        sendUnindentedElement(PSVIUni::fgSchemaDocuments);
626}
627
628void PSVIWriterHandlers::processSchemaAnnotations(XSAnnotationList* annotations) {
629        if (annotations == NULL || annotations->size()==0) {
630                sendElementEmpty(PSVIUni::fgSchemaAnnotations);
631        } else {
632                sendIndentedElement(PSVIUni::fgSchemaAnnotations);
633                for (unsigned int i = 0; i < annotations->size(); i++) {
634                        processAnnotation(annotations->elementAt(i));
635                }
636                sendUnindentedElement(PSVIUni::fgSchemaAnnotations);
637        }
638}
639
640void PSVIWriterHandlers::processSchemaErrorCode(StringList* /* errors */ ) {
641        //REVISIT
642        //ErrorCodes not yet supported
643}
644
645void PSVIWriterHandlers::processTypeDefinition(XSTypeDefinition* type) {
646        if (type->getTypeCategory() == XSTypeDefinition::COMPLEX_TYPE) {
647                processComplexTypeDefinition((XSComplexTypeDefinition*)type);
648        } else { //XSTypeDefinition::SIMPLE_TYPE
649                processSimpleTypeDefinition((XSSimpleTypeDefinition*)type);
650        }
651}
652
653void PSVIWriterHandlers::processComplexTypeDefinition(XSComplexTypeDefinition* complexType) {
654        sendIndentedElementWithID(PSVIUni::fgComplexTypeDefinition, (XSObject*) complexType);
655        if (complexType->getAnonymous())
656                sendElementEmpty(PSVIUni::fgName);
657        else sendElementValue(PSVIUni::fgName, complexType->getName());
658        sendElementValue(PSVIUni::fgTargetNamespace, complexType->getNamespace());
659        processTypeDefinitionOrRef(PSVIUni::fgBaseTypeDefinition, complexType->getBaseType());
660        sendElementValue(PSVIUni::fgDerivationMethod,
661                translateDerivationMethod(complexType->getDerivationMethod()));
662        sendElementValue(PSVIUni::fgFinal, translateBlockOrFinal(complexType->getFinal()));
663        sendElementValue(PSVIUni::fgAbstract, translateBool(complexType->getAbstract()));
664        processAttributeUses(complexType->getAttributeUses());
665        processAttributeWildcard(complexType->getAttributeWildcard());
666
667        sendIndentedElement(PSVIUni::fgContentType);
668        sendElementValue(PSVIUni::fgVariety, translateComplexContentType(complexType->getContentType()));
669        if (complexType->getSimpleType()==NULL) {
670                sendElementEmpty(PSVIUni::fgSimpleTypeDefinition);
671        } else {
672                processSimpleTypeDefinitionOrRef(complexType->getSimpleType());
673        }
674        processParticle(complexType->getParticle());
675        sendUnindentedElement(PSVIUni::fgContentType);
676        sendElementValue(PSVIUni::fgProhibitedSubstitutions,
677                translateBlockOrFinal(complexType->getProhibitedSubstitutions()));
678        processAnnotations(complexType->getAnnotations());
679        sendUnindentedElement(PSVIUni::fgComplexTypeDefinition);
680}
681
682void PSVIWriterHandlers::processSimpleTypeDefinition(XSSimpleTypeDefinition* simpleType) {
683        sendIndentedElementWithID(PSVIUni::fgSimpleTypeDefinition, (XSObject*) simpleType);
684        if (simpleType->getAnonymous())
685                sendElementEmpty(PSVIUni::fgName);
686        else sendElementValue(PSVIUni::fgName, simpleType->getName());
687        sendElementValue(PSVIUni::fgTargetNamespace, simpleType->getNamespace());
688        processTypeDefinitionOrRef(PSVIUni::fgBaseTypeDefinition, simpleType->getBaseType());
689        processTypeDefinitionOrRef(PSVIUni::fgPrimitiveTypeDefinition, simpleType->getPrimitiveType());
690        processFacets(simpleType->getFacets(), simpleType->getMultiValueFacets());
691        processFundamentalFacets(simpleType);
692        sendElementValue(PSVIUni::fgFinal, translateBlockOrFinal(simpleType->getFinal()));
693        sendElementValue(PSVIUni::fgVariety, translateSimpleTypeVariety(simpleType->getVariety()));
694        processTypeDefinitionOrRef(PSVIUni::fgItemTypeDefinition, simpleType->getItemType());
695        processMemberTypeDefinitions(simpleType->getMemberTypes());
696        processAnnotations(simpleType->getAnnotations());
697        sendUnindentedElement(PSVIUni::fgSimpleTypeDefinition);
698}
699
700void PSVIWriterHandlers::processModelGroupDefinition(XSModelGroupDefinition* modelGroup) {
701        if (modelGroup == NULL) {
702                sendElementEmpty(PSVIUni::fgModelGroupDefinition);
703        } else {
704                sendIndentedElementWithID(PSVIUni::fgModelGroupDefinition, (XSObject*) modelGroup);
705                sendElementValue(PSVIUni::fgName, modelGroup->getName());
706                sendElementValue(PSVIUni::fgTargetNamespace, modelGroup->getNamespace());
707                processModelGroup(modelGroup->getModelGroup());
708                processAnnotation(modelGroup->getAnnotation());
709                sendUnindentedElement(PSVIUni::fgModelGroupDefinition);
710        }
711}
712
713void PSVIWriterHandlers::processAttributeGroupDefinition(XSAttributeGroupDefinition* attributeGroup) {
714        if (attributeGroup == NULL) {
715                sendElementEmpty(PSVIUni::fgAttributeGroupDefinition);
716        } else {
717                sendIndentedElementWithID(PSVIUni::fgAttributeGroupDefinition, (XSObject*) attributeGroup);
718                sendElementValue(PSVIUni::fgName, attributeGroup->getName());
719                sendElementValue(PSVIUni::fgTargetNamespace, attributeGroup->getNamespace());
720                processAttributeUses(attributeGroup->getAttributeUses());
721                processAttributeWildcard(attributeGroup->getAttributeWildcard());
722                processAnnotation(attributeGroup->getAnnotation());
723                sendUnindentedElement(PSVIUni::fgAttributeGroupDefinition);
724        }
725}
726
727void PSVIWriterHandlers::processElementDeclaration(XSElementDeclaration* element) {
728        if (element == NULL) {
729                sendElementEmpty(PSVIUni::fgElementDeclaration);
730        } else {
731                sendIndentedElementWithID(PSVIUni::fgElementDeclaration, (XSObject*) element);
732                sendElementValue(PSVIUni::fgName, element->getName());
733                sendElementValue(PSVIUni::fgTargetNamespace, element->getNamespace());
734                processTypeDefinitionOrRef(PSVIUni::fgTypeDefinition, element->getTypeDefinition());
735                processScope(element->getEnclosingCTDefinition(), element->getScope());
736                processValueConstraint(element->getConstraintType(), element->getConstraintValue());
737                sendElementValue(PSVIUni::fgNillable, translateBool(element->getNillable()));
738                processIdentityConstraintDefinition(element->getIdentityConstraints());
739                processElementDeclarationRef(PSVIUni::fgSubstitutionGroupAffiliation,
740                        element->getSubstitutionGroupAffiliation());
741                sendElementValue(PSVIUni::fgSubstitutionGroupExclusions,
742                        translateBlockOrFinal(element->getSubstitutionGroupExclusions()));
743                sendElementValue(PSVIUni::fgDisallowedSubstitutions,
744                        translateBlockOrFinal(element->getDisallowedSubstitutions()));
745                sendElementValue(PSVIUni::fgAbstract, translateBool(element->getAbstract()));
746                processAnnotation(element->getAnnotation());
747                sendUnindentedElement(PSVIUni::fgElementDeclaration);
748        }
749}
750
751void PSVIWriterHandlers::processAttributeDeclaration(XSAttributeDeclaration* attribute) {
752        if (attribute == NULL) {
753                sendElementEmpty(PSVIUni::fgAttributeDeclaration);
754        } else {
755                sendIndentedElementWithID(PSVIUni::fgAttributeDeclaration, (XSObject*) attribute);
756                sendElementValue(PSVIUni::fgName, attribute->getName());
757                sendElementValue(PSVIUni::fgTargetNamespace, attribute->getNamespace());
758                sendIndentedElement(PSVIUni::fgTypeDefinition);
759                processSimpleTypeDefinitionOrRef(attribute->getTypeDefinition());
760                sendUnindentedElement(PSVIUni::fgTypeDefinition);
761                processScope(attribute->getEnclosingCTDefinition(), attribute->getScope());
762                processValueConstraint(attribute->getConstraintType(), attribute->getConstraintValue());
763                processAnnotation(attribute->getAnnotation());
764                sendUnindentedElement(PSVIUni::fgAttributeDeclaration);
765        }
766}
767
768void PSVIWriterHandlers::processNotationDeclaration(XSNotationDeclaration* notation) {
769        if (notation == NULL) {
770                sendElementEmpty(PSVIUni::fgNotationDeclaration);
771        } else {
772                sendIndentedElementWithID(PSVIUni::fgNotationDeclaration, (XSObject*) notation);
773                sendElementValue(PSVIUni::fgName, notation->getName());
774                sendElementValue(PSVIUni::fgTargetNamespace, notation->getNamespace());
775                sendElementValue(PSVIUni::fgSystemIdentifier, notation->getSystemId());
776                sendElementValue(PSVIUni::fgPublicIdentifier, notation->getPublicId());
777                processAnnotation(notation->getAnnotation());
778                sendUnindentedElement(PSVIUni::fgNotationDeclaration);
779        }
780}
781
782void PSVIWriterHandlers::processAnnotations(XSAnnotationList* annotations) {
783        if (annotations == NULL) {
784                sendElementEmpty(PSVIUni::fgAnnotations);
785        } else {
786                sendIndentedElement(PSVIUni::fgAnnotations);
787                for (unsigned int i = 0; i < annotations->size(); i++) {
788                        processAnnotation(annotations->elementAt(i));
789                }
790                sendUnindentedElement(PSVIUni::fgAnnotations);
791        }
792}
793
794void PSVIWriterHandlers::processAttributeUses(XSAttributeUseList* attributeUses) {
795        if (attributeUses == NULL) {
796                sendElementEmpty(PSVIUni::fgAttributeUses);
797        } else {
798                sendIndentedElement(PSVIUni::fgAttributeUses);
799                XSAttributeUse* attrUse;
800                for (unsigned int i=0; i < attributeUses->size(); i++) {
801                        attrUse = attributeUses->elementAt(i);
802                        sendIndentedElement(PSVIUni::fgAttributeUse);
803                        sendElementValue(PSVIUni::fgRequired, translateBool(attrUse->getRequired()));
804                        processAttributeDeclarationOrRef(attrUse->getAttrDeclaration());
805                        processValueConstraint(attrUse->getConstraintType(), attrUse->getConstraintValue());
806                        sendUnindentedElement(PSVIUni::fgAttributeUse);
807                }
808                sendUnindentedElement(PSVIUni::fgAttributeUses);
809        }
810}
811
812void PSVIWriterHandlers::processFacets(XSFacetList* facets, XSMultiValueFacetList* multiFacets) {
813        if (facets == NULL && multiFacets == NULL) {
814                sendElementEmpty(PSVIUni::fgFacets);
815        } else {
816                sendIndentedElement(PSVIUni::fgFacets);
817                if (facets != NULL) {
818                        for (unsigned int facetCount = 0; facetCount < facets->size(); facetCount++) {
819                                XSFacet* facet = facets->elementAt(facetCount);
820                                sendIndentedElement(translateFacet(facet->getFacetKind()));
821                                sendElementValue(PSVIUni::fgValue, facet->getLexicalFacetValue());
822                                sendElementValue(PSVIUni::fgFacetFixed, translateBool(facet->isFixed()));
823                                processAnnotation(facet->getAnnotation());
824                                sendUnindentedElement(translateFacet(facet->getFacetKind()));
825                        }
826                }
827                if (multiFacets != NULL) {
828                        for (unsigned int multiFacetCount = 0; multiFacetCount < multiFacets->size(); multiFacetCount++) {
829                                XSMultiValueFacet* multiFacet = multiFacets->elementAt(multiFacetCount);
830                                sendIndentedElement(translateFacet(multiFacet->getFacetKind()));
831                                StringList* values = multiFacet->getLexicalFacetValues();
832                                for (unsigned int i=0; i < values->size(); i++) {
833                                        sendElementValue(PSVIUni::fgValue, values->elementAt(i));
834                                }
835                                sendElementValue(PSVIUni::fgFacetFixed, translateBool(multiFacet->isFixed()));
836                                processAnnotations(multiFacet->getAnnotations());
837                                sendUnindentedElement(translateFacet(multiFacet->getFacetKind()));
838                        }
839                }
840                sendUnindentedElement(PSVIUni::fgFacets);
841        }
842}
843
844void PSVIWriterHandlers::processFundamentalFacets(XSSimpleTypeDefinition* type) {
845        sendIndentedElement(PSVIUni::fgFundamentalFacets);
846        sendIndentedElement(PSVIUni::fgOrdered);
847        sendElementValue(PSVIUni::fgValue, translateOrderedFacet(type->getOrdered()));
848        sendUnindentedElement(PSVIUni::fgOrdered);
849        sendIndentedElement(PSVIUni::fgBounded);
850        sendElementValue(PSVIUni::fgValue, translateBool(type->getBounded()));
851        sendUnindentedElement(PSVIUni::fgBounded);
852        sendIndentedElement(PSVIUni::fgCardinality);
853        sendElementValue(PSVIUni::fgValue, translateBool(type->getFinite()));
854        sendUnindentedElement(PSVIUni::fgCardinality);
855        sendIndentedElement(PSVIUni::fgNumeric);
856        sendElementValue(PSVIUni::fgValue, translateBool(type->getNumeric()));
857        sendUnindentedElement(PSVIUni::fgNumeric);
858        sendUnindentedElement(PSVIUni::fgFundamentalFacets);
859}
860
861void PSVIWriterHandlers::processMemberTypeDefinitions(XSSimpleTypeDefinitionList* memberTypes) {
862        if (memberTypes == NULL) {
863                sendElementEmpty(PSVIUni::fgMemberTypeDefinitions);
864        } else {
865                sendIndentedElement(PSVIUni::fgMemberTypeDefinitions);
866                for (unsigned int i = 0; i < memberTypes->size(); i++) {
867                        processTypeDefinitionOrRef(PSVIUni::fgMemberTypeDefinition, (XSTypeDefinition*)memberTypes->elementAt(i));
868                }
869                sendUnindentedElement(PSVIUni::fgMemberTypeDefinitions);
870        }
871}
872
873void PSVIWriterHandlers::processAnnotation(XSAnnotation* annotation) {
874        if (annotation == NULL) {
875                sendElementEmpty(PSVIUni::fgAnnotation);
876        } else {
877        XSAnnotation* annot;
878        annot = annotation;
879
880        while (annot) {
881                    XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* document = DOMImplementationRegistry::getDOMImplementation(XMLUni::fgZeroLenString)->
882                createDocument();
883                    annot->writeAnnotation((DOMNode*)document, XSAnnotation::W3C_DOM_DOCUMENT);
884                    DOMElement* elem = document->getDocumentElement();
885                    sendIndentedElement(PSVIUni::fgAnnotation);
886                    processDOMElement(PSVIUni::fgApplicationInformation, elem, PSVIUni::fgAppinfo);
887                    processDOMElement(PSVIUni::fgUserInformation, elem, PSVIUni::fgDocumentation);
888                    processDOMAttributes(elem->getAttributes());
889                    sendUnindentedElement(PSVIUni::fgAnnotation);
890            document->release();
891            annot = annot->getNext();
892        }
893        }
894}
895
896void PSVIWriterHandlers::processDOMElement(const XMLCh* const encloseName, DOMElement* rootElem, const XMLCh* const elementName) {
897        DOMNodeList* elems = rootElem->getElementsByTagNameNS(SchemaSymbols::fgURI_SCHEMAFORSCHEMA, elementName);
898        if (elems->getLength()==0) {
899                sendElementEmpty(encloseName);
900        } else {
901                sendIndentedElement(encloseName);
902                for (XMLSize_t i=0; i < elems->getLength(); i++) {
903                        DOMElement* elem = (DOMElement*)elems->item(i);
904                        sendIndentedElement(PSVIUni::fgElement);
905                        sendElementValue(PSVIUni::fgNamespaceName, elem->getNamespaceURI());
906                        sendElementValue(PSVIUni::fgLocalName, elem->getLocalName());
907                        sendElementValue(PSVIUni::fgPrefix, elem->getPrefix());
908                        sendIndentedElement(PSVIUni::fgChildren);
909                        sendIndentedElement(PSVIUni::fgCharacter);
910                        sendElementValue(PSVIUni::fgTextContent, elem->getTextContent());
911                        sendUnindentedElement(PSVIUni::fgCharacter);
912                        sendUnindentedElement(PSVIUni::fgChildren);
913                        processDOMAttributes(elem->getAttributes());
914                        sendUnindentedElement(PSVIUni::fgElement);
915                }
916                sendUnindentedElement(encloseName);
917        }
918}
919
920void PSVIWriterHandlers::processDOMAttributes(DOMNamedNodeMap* attrs) {
921        fNSAttributes->removeAllElements();
922        bool firstFlag = true;
923        for (XMLSize_t count=0; count < attrs->getLength(); count++) {
924                DOMAttr* attr = (DOMAttr*)attrs->item(count);
925        if (XMLString::equals(attr->getNamespaceURI(), XMLUni::fgXMLNSURIName)) {
926                        fNSAttributes->addElement(count);
927                } else {
928                        if (firstFlag) {
929                                sendIndentedElement(PSVIUni::fgAttributes);
930                                firstFlag = false;
931                        }
932                        sendIndentedElement(PSVIUni::fgAttribute);
933                        sendElementValue(PSVIUni::fgNamespaceName, attr->getNamespaceURI());
934                        sendElementValue(PSVIUni::fgLocalName, attr->getLocalName());
935                        sendElementValue(PSVIUni::fgPrefix, attr->getPrefix());
936                        sendElementValue(PSVIUni::fgNormalizedValue, attr->getValue());
937                        sendElementValue(PSVIUni::fgSpecified, translateBool(attr->getSpecified()));
938                        sendElementValue(PSVIUni::fgAttributeType, attr->getSchemaTypeInfo()->getTypeName());
939                        sendElementEmpty(PSVIUni::fgReferences);
940                        sendUnindentedElement(PSVIUni::fgAttribute);
941                }
942        }
943        if (firstFlag)
944                writeEmpty(PSVIUni::fgAttributes);
945        else
946                sendUnindentedElement(PSVIUni::fgAttributes);
947
948        //now for namespace attributes
949        if (fNSAttributes->size()==0) {
950                writeEmpty(PSVIUni::fgNamespaceAttributes);
951        } else {
952                sendIndentedElement(PSVIUni::fgNamespaceAttributes);
953                for (XMLSize_t NScount = 0; NScount < fNSAttributes->size(); NScount++) {
954                        DOMAttr* attr = (DOMAttr*)attrs->item(fNSAttributes->elementAt(NScount));
955                        sendIndentedElement(PSVIUni::fgAttribute);
956                        sendElementValue(PSVIUni::fgNamespaceName, XMLUni::fgXMLNSURIName);
957                        sendElementValue(PSVIUni::fgLocalName, attr->getLocalName());
958                        sendElementValue(PSVIUni::fgPrefix, attr->getPrefix());
959                        sendElementValue(PSVIUni::fgNormalizedValue, attr->getValue());
960                        sendElementValue(PSVIUni::fgSpecified, translateBool(attr->getSpecified()));
961                        sendElementValue(PSVIUni::fgAttributeType, attr->getSchemaTypeInfo()->getTypeName());
962                        sendElementEmpty(PSVIUni::fgReferences);
963                        sendUnindentedElement(PSVIUni::fgAttribute);
964                }
965                sendUnindentedElement(PSVIUni::fgNamespaceAttributes);
966        }
967}
968
969void PSVIWriterHandlers::processWildcard(XSWildcard* wildcard) {
970        if (wildcard == NULL) {
971                sendElementEmpty(PSVIUni::fgWildcard);
972        } else {
973                sendIndentedElement(PSVIUni::fgWildcard);
974                sendIndentedElement(PSVIUni::fgNamespaceConstraint);
975                if (wildcard->getConstraintType()==XSWildcard::NSCONSTRAINT_ANY) {
976                        sendElementValue(PSVIUni::fgVariety, PSVIUni::fgAny);
977                        sendElementEmpty(PSVIUni::fgNamespaces);
978                } else {
979                        if (wildcard->getConstraintType()==XSWildcard::NSCONSTRAINT_DERIVATION_LIST) {
980                                sendElementEmpty(PSVIUni::fgVariety);
981                                sendElementValueList(PSVIUni::fgNamespaces, wildcard->getNsConstraintList());
982                        } else {  //NSCONSTRAINT_NOT
983                                sendElementValue(PSVIUni::fgVariety, PSVIUni::fgNot);
984                                sendElementValueList(PSVIUni::fgNamespaces, wildcard->getNsConstraintList());
985                        }
986                }
987                sendUnindentedElement(PSVIUni::fgNamespaceConstraint);
988                sendElementValue(PSVIUni::fgProcessContents,
989                        translateProcessContents(wildcard->getProcessContents()));
990                processAnnotation(wildcard->getAnnotation());
991                sendUnindentedElement(PSVIUni::fgWildcard);
992        }
993}
994
995void PSVIWriterHandlers::processModelGroup(XSModelGroup* modelGroup) {
996        if (modelGroup == NULL) {
997                sendElementEmpty(PSVIUni::fgModelGroup);
998        } else {
999                sendIndentedElement(PSVIUni::fgModelGroup);
1000                sendElementValue(PSVIUni::fgCompositor, translateCompositor(modelGroup->getCompositor()));
1001                sendIndentedElement(PSVIUni::fgParticles);
1002                for (unsigned int i=0; i < modelGroup->getParticles()->size(); i++) {
1003                        processParticle(modelGroup->getParticles()->elementAt(i));
1004                }
1005                sendUnindentedElement(PSVIUni::fgParticles);
1006                processAnnotation(modelGroup->getAnnotation());
1007                sendUnindentedElement(PSVIUni::fgModelGroup);
1008        }
1009}
1010
1011void PSVIWriterHandlers::processParticle(XSParticle* particle) {
1012        if (particle == NULL) {
1013                sendElementEmpty(PSVIUni::fgParticle);
1014        } else {
1015                sendIndentedElement(PSVIUni::fgParticle);
1016                sendElementValueInt(PSVIUni::fgMinOccurs, particle->getMinOccurs());
1017                if (particle->getMaxOccursUnbounded()) {
1018                        sendElementValue(PSVIUni::fgMaxOccurs, PSVIUni::fgUnbounded);
1019                } else {
1020                        sendElementValueInt(PSVIUni::fgMaxOccurs,particle->getMaxOccurs());
1021                }
1022                sendIndentedElement(PSVIUni::fgTerm);
1023                switch (particle->getTermType()) {
1024            case XSParticle::TERM_ELEMENT:
1025                                processElementDeclarationOrRef(particle->getElementTerm());
1026                                break;
1027            case XSParticle::TERM_MODELGROUP:
1028                                processModelGroup(particle->getModelGroupTerm());
1029                                break;
1030            case XSParticle::TERM_WILDCARD:
1031                                processWildcard(particle->getWildcardTerm());
1032                break;
1033            default:
1034                break;
1035                }
1036                sendUnindentedElement(PSVIUni::fgTerm);
1037                sendUnindentedElement(PSVIUni::fgParticle);
1038        }
1039}
1040
1041void PSVIWriterHandlers::processAttributeWildcard(XSWildcard* wildcard) {
1042        if (wildcard == NULL) {
1043                sendElementEmpty(PSVIUni::fgAttributeWildcard);
1044        } else {
1045                sendIndentedElement(PSVIUni::fgAttributeWildcard);
1046                processWildcard(wildcard);
1047                sendUnindentedElement(PSVIUni::fgAttributeWildcard);
1048        }
1049}
1050
1051void PSVIWriterHandlers::processScope(XSComplexTypeDefinition* enclosingCTD, short scope) {
1052        switch (scope) {
1053                case XSConstants::SCOPE_ABSENT:
1054                        sendElementEmpty(PSVIUni::fgScope);
1055                        break;
1056                case XSConstants::SCOPE_LOCAL:
1057                        sendIndentedElement(PSVIUni::fgScope);
1058                        sendReference(PSVIUni::fgComplexTypeDefinition, enclosingCTD);
1059                        sendUnindentedElement(PSVIUni::fgScope);
1060                        break;
1061                case XSConstants::SCOPE_GLOBAL:
1062                        sendElementValue(PSVIUni::fgScope, PSVIUni::fgGlobal);
1063        }
1064}
1065
1066void PSVIWriterHandlers::processValueConstraint(XSConstants::VALUE_CONSTRAINT valueConstraintType, const XMLCh* constraintValue) {
1067        if (valueConstraintType == XSConstants::VALUE_CONSTRAINT_NONE) {
1068                sendElementEmpty(PSVIUni::fgValueConstraint);
1069        } else {
1070                sendIndentedElement(PSVIUni::fgValueConstraint);
1071                sendElementValue(PSVIUni::fgVariety, translateValueConstraint(valueConstraintType));
1072                sendElementValue(PSVIUni::fgValue, constraintValue);
1073                sendUnindentedElement(PSVIUni::fgValueConstraint);
1074        }
1075}
1076
1077void PSVIWriterHandlers::processIdentityConstraintDefinition(XSNamedMap<XSIDCDefinition>* idConstraint) {
1078        if (idConstraint == NULL) {
1079                sendElementEmpty(PSVIUni::fgIdentityConstraintDefinitions);
1080        } else {
1081                sendIndentedElement(PSVIUni::fgIdentityConstraintDefinitions);
1082                for (XMLSize_t i=0; i < idConstraint->getLength(); i++) {
1083                        XSIDCDefinition* constraint = idConstraint->item(i);
1084                        sendIndentedElementWithID(PSVIUni::fgIdentityConstraintDefinition, (XSObject*) constraint);
1085                        sendElementValue(PSVIUni::fgName, constraint->getName());
1086                        sendElementValue(PSVIUni::fgTargetNamespace, constraint->getNamespace());
1087                        sendElementValue(PSVIUni::fgIdentityConstraintCategory, translateIdConstraintCategory(constraint->getCategory()));
1088                        sendIndentedElement(PSVIUni::fgSelector);
1089                        processXPath(constraint->getSelectorStr());
1090                        sendUnindentedElement(PSVIUni::fgSelector);
1091                        processFields(constraint->getFieldStrs());
1092                        sendReference(PSVIUni::fgReferencedKey, constraint->getRefKey());
1093                        processAnnotations(constraint->getAnnotations());
1094                        sendUnindentedElement(PSVIUni::fgIdentityConstraintDefinition);
1095                }
1096                sendUnindentedElement(PSVIUni::fgIdentityConstraintDefinitions);
1097        }
1098}
1099
1100void PSVIWriterHandlers::processFields(StringList* fields) {
1101        sendIndentedElement(PSVIUni::fgFields);
1102        for (unsigned int i=0; i < fields->size(); i++) {
1103                processXPath(fields->elementAt(i));
1104        }
1105        sendUnindentedElement(PSVIUni::fgFields);
1106}
1107
1108void PSVIWriterHandlers::processXPath(const XMLCh* xpath) {
1109        sendIndentedElement(PSVIUni::fgXpath);
1110        sendElementValue(PSVIUni::fgXpath, xpath);
1111        sendUnindentedElement(PSVIUni::fgXpath);
1112}
1113
1114void PSVIWriterHandlers::processChildren() {
1115        if (!fElementChildren->empty() && !fElementChildren->peek()) {
1116                fElementChildren->pop();
1117                sendIndentedElement(PSVIUni::fgChildren);
1118                fElementChildren->push(true);
1119        }
1120}
1121
1122void PSVIWriterHandlers::processChildrenEnd() {
1123        if (fElementChildren->pop()) {
1124                sendUnindentedElement(PSVIUni::fgChildren);
1125        } else {
1126                writeEmpty(PSVIUni::fgChildren);
1127        }
1128}
1129
1130void PSVIWriterHandlers::processTypeDefinitionOrRef(const XMLCh* enclose, XSTypeDefinition* type) {
1131        if (type==NULL) {
1132                sendElementEmpty(enclose);
1133        } else {
1134                sendIndentedElement(enclose);
1135                if (type->getAnonymous() && !(fDefinedIds->containsElement(type))) {
1136                        processTypeDefinition(type);
1137                } else {
1138                        if (type->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE) {
1139                                sendReference(PSVIUni::fgSimpleTypeDefinition, type);
1140                        } else {
1141                                sendReference(PSVIUni::fgComplexTypeDefinition, type);
1142                        }
1143                }
1144                sendUnindentedElement(enclose);
1145        }
1146}
1147
1148void PSVIWriterHandlers::processSimpleTypeDefinitionOrRef(XSSimpleTypeDefinition* type) {
1149        if (type==NULL) {
1150                sendElementEmpty(PSVIUni::fgSimpleTypeDefinition);
1151        } else {
1152                if (type->getAnonymous() && !(fDefinedIds->containsElement(type))) {
1153                        processSimpleTypeDefinition(type);
1154                } else {
1155                        sendReference(PSVIUni::fgSimpleTypeDefinition, type);
1156                }
1157        }
1158}
1159
1160void PSVIWriterHandlers::processAttributeDeclarationOrRef(XSAttributeDeclaration* attrDecl) {
1161        if (attrDecl==NULL) {
1162                sendElementEmpty(PSVIUni::fgAttributeDeclaration);
1163        } else {
1164                if (fDefinedIds->containsElement(attrDecl) ||
1165                                (attrDecl->getScope() == XSConstants::SCOPE_GLOBAL)) {
1166                        sendReference(PSVIUni::fgAttributeDeclaration, attrDecl);
1167                } else {
1168                        processAttributeDeclaration(attrDecl);
1169                }
1170        }
1171}
1172
1173void PSVIWriterHandlers::processElementDeclarationOrRef(XSElementDeclaration* elemDecl) {
1174        if (elemDecl==NULL) {
1175                sendElementEmpty(PSVIUni::fgElementDeclaration);
1176        } else {
1177                if (fDefinedIds->containsElement(elemDecl) ||
1178                                (elemDecl->getScope() == XSConstants::SCOPE_GLOBAL)) {
1179                        sendReference(PSVIUni::fgElementDeclaration, elemDecl);
1180                } else {
1181                        processElementDeclaration(elemDecl);
1182                }
1183        }
1184}
1185
1186void PSVIWriterHandlers::processTypeDefinitionRef(const XMLCh* enclose, XSTypeDefinition* type) {
1187        if (type==NULL) {
1188                sendElementEmpty(enclose);
1189        } else {
1190                sendIndentedElement(enclose);
1191                if (type->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE) {
1192                        sendReference(PSVIUni::fgSimpleTypeDefinition, type);
1193                } else {
1194                        sendReference(PSVIUni::fgComplexTypeDefinition, type);
1195                }
1196                sendUnindentedElement(enclose);
1197        }
1198}
1199
1200void PSVIWriterHandlers::processAttributeDeclarationRef(const XMLCh* /* enclose */, XSAttributeDeclaration* attrDecl) {
1201        if (attrDecl == NULL) {
1202                sendElementEmpty(PSVIUni::fgDeclaration);
1203        } else {
1204                sendIndentedElement(PSVIUni::fgDeclaration);
1205                sendReference(PSVIUni::fgAttributeDeclaration, attrDecl);
1206                sendUnindentedElement(PSVIUni::fgDeclaration);
1207        }
1208}
1209
1210void PSVIWriterHandlers::processElementDeclarationRef(const XMLCh* enclose, XSElementDeclaration* elemDecl) {
1211        if (elemDecl==NULL) {
1212                sendElementEmpty(enclose);
1213        } else {
1214                sendIndentedElement(enclose);
1215                sendReference(PSVIUni::fgElementDeclaration, elemDecl);
1216                sendUnindentedElement(enclose);
1217        }
1218}
1219
1220void PSVIWriterHandlers::sendReference(const XMLCh* elementName, XSObject* obj) {
1221        if (obj==NULL) {
1222                sendElementEmpty(elementName);
1223        } else {
1224                fAttrList->removeAllElements();
1225                fAttrList->addElement((XMLCh*)gRef);
1226                fAttrList->addElement((XMLCh*)getIdName(obj));
1227                fAttrList->addElement((XMLCh*)fgXsiNil);
1228                fAttrList->addElement((XMLCh*)PSVIUni::fgTrue);
1229                writeEmpty(elementName, fAttrList);
1230        }
1231}
1232
1233void PSVIWriterHandlers::sendElementEmpty(const XMLCh* const elementName) {
1234        fAttrList->removeAllElements();
1235        fAttrList->addElement((XMLCh*)fgXsiNil);
1236        fAttrList->addElement((XMLCh*)PSVIUni::fgTrue);
1237        writeEmpty(elementName, fAttrList);
1238}
1239
1240void PSVIWriterHandlers::sendElementValueInt(const XMLCh* const elementName, int value) {
1241        XMLString::binToText(value, fTempResult, 50, 10);
1242        writeValue(elementName, fTempResult);
1243}
1244
1245void PSVIWriterHandlers::sendElementValue(const XMLCh* const elementName, const XMLCh* const value) {
1246        if (value==NULL || XMLString::equals(value, XMLUni::fgZeroLenString)) {
1247                sendElementEmpty(elementName);
1248        } else {
1249                writeValue(elementName, value);
1250        }
1251}
1252
1253void PSVIWriterHandlers::sendElementValueList(const XMLCh* const elementName, const StringList* const values) {
1254        if (values==NULL) {
1255                sendElementEmpty(elementName);
1256        } else {
1257                writeValue(elementName, values);
1258        }
1259}
1260
1261void PSVIWriterHandlers::sendIndentedElement(const XMLCh* const elementName) {
1262        writeOpen(elementName);
1263        incIndent();
1264}
1265
1266void PSVIWriterHandlers::sendIndentedElementWithID(const XMLCh* const elementName, XSObject* obj) {
1267        fDefinedIds->addElement(obj);
1268        fAttrList->removeAllElements();
1269        fAttrList->addElement((XMLCh*)gId);
1270        fAttrList->addElement((XMLCh*)getIdName(obj));
1271        writeOpen(elementName, fAttrList);
1272        incIndent();
1273}
1274
1275void PSVIWriterHandlers::sendUnindentedElement(const XMLCh* const elementName) {
1276        decIndent();
1277        writeClose(elementName);
1278}
1279
1280void PSVIWriterHandlers::writeOpen(const XMLCh* const elementName) {
1281        *fFormatter
1282                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName << gAngleFeed;
1283}
1284
1285void PSVIWriterHandlers::writeOpen(const XMLCh* const elementName, const StringList* const attrs) {
1286        *fFormatter
1287                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName ;
1288        for (unsigned int i=0; i < attrs->size(); i+=2 ) {
1289                *fFormatter
1290                        << XMLFormatter::NoEscapes << chSpace << attrs->elementAt(i) << gEqualsQuote
1291                        << XMLFormatter::AttrEscapes << attrs->elementAt(i+1)
1292                        << XMLFormatter::NoEscapes << chDoubleQuote ;
1293        }
1294        *fFormatter
1295                << XMLFormatter::NoEscapes << gAngleFeed;
1296}
1297
1298void PSVIWriterHandlers::writeClose(const XMLCh* const elementName) {
1299        *fFormatter
1300                << XMLFormatter::NoEscapes << fIndentChars << gAngleSlash << elementName << gAngleFeed;
1301}
1302
1303void PSVIWriterHandlers::writeValue(const XMLCh* const elementName, const XMLCh* const value) {
1304        *fFormatter
1305                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName << chCloseAngle
1306                << XMLFormatter::CharEscapes << value
1307                << XMLFormatter::NoEscapes << gAngleSlash << elementName <<     gAngleFeed ;
1308}
1309
1310void PSVIWriterHandlers::writeValue(const XMLCh* const elementName, const StringList* const values) {
1311        *fFormatter
1312                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName << chCloseAngle;
1313        for (unsigned int i=0; i < values->size(); i++) {
1314                *fFormatter
1315                        << XMLFormatter::CharEscapes << values->elementAt(i) << chSpace;
1316        }
1317        *fFormatter
1318                << XMLFormatter::NoEscapes << gAngleSlash << elementName <<     gAngleFeed ;
1319}
1320
1321void PSVIWriterHandlers::writeEmpty(const XMLCh* const elementName, const StringList* const attrs) {
1322        *fFormatter
1323                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName ;
1324        for (unsigned int i=0; i < attrs->size(); i+=2 ) {
1325                *fFormatter
1326                        << XMLFormatter::NoEscapes << chSpace << attrs->elementAt(i) << gEqualsQuote
1327                        << XMLFormatter::AttrEscapes << attrs->elementAt(i+1)
1328                        << XMLFormatter::NoEscapes << chDoubleQuote ;
1329        }
1330        *fFormatter
1331                << XMLFormatter::NoEscapes << gSlashAngleFeed ;
1332}
1333
1334void PSVIWriterHandlers::writeEmpty(const XMLCh* const elementName) {
1335        *fFormatter
1336                << XMLFormatter::NoEscapes << fIndentChars << chOpenAngle << elementName << gSlashAngleFeed ;
1337}
1338
1339void PSVIWriterHandlers::writeString(const XMLCh* const string) {
1340        *fFormatter
1341                << XMLFormatter::NoEscapes << fIndentChars << string;
1342}
1343
1344const XMLCh* PSVIWriterHandlers::translateScope(XSConstants::SCOPE scope) {
1345        switch (scope) {
1346                case XSConstants::SCOPE_ABSENT :
1347                        return NULL;
1348                case XSConstants::SCOPE_GLOBAL :
1349                        return PSVIUni::fgGlobal;
1350                case XSConstants::SCOPE_LOCAL :
1351                        return PSVIUni::fgLocal;
1352                default :
1353                        return PSVIUni::fgUnknown;
1354        }
1355}
1356
1357const XMLCh* PSVIWriterHandlers::translateValueConstraint(XSConstants::VALUE_CONSTRAINT constraintKind) {
1358        switch (constraintKind) {
1359                case XSConstants::VALUE_CONSTRAINT_DEFAULT :
1360                        return PSVIUni::fgDefault;
1361                case XSConstants::VALUE_CONSTRAINT_FIXED :
1362                        return PSVIUni::fgVCFixed;
1363                default :
1364                        return PSVIUni::fgUnknown;
1365        }
1366}
1367
1368const XMLCh* PSVIWriterHandlers::translateBlockOrFinal(short val) {
1369        XMLString::copyString(fTempResult, XMLUni::fgZeroLenString);
1370        if ((val & XSConstants::DERIVATION_EXTENSION) != 0) {
1371                XMLString::catString(fTempResult, PSVIUni::fgExtension);
1372        }
1373        if ((val & XSConstants::DERIVATION_RESTRICTION) != 0) {
1374                if (fTempResult && *fTempResult)
1375                        XMLString::catString(fTempResult, fgSpace);
1376                XMLString::catString(fTempResult, PSVIUni::fgRestriction);
1377        }
1378        if ((val & XSConstants::DERIVATION_LIST) != 0) {
1379                if (fTempResult && *fTempResult)
1380                        XMLString::catString(fTempResult, fgSpace);
1381                XMLString::catString(fTempResult, PSVIUni::fgList);
1382        }
1383        if ((val & XSConstants::DERIVATION_UNION) != 0) {
1384                if (fTempResult && *fTempResult)
1385                        XMLString::catString(fTempResult, fgSpace);
1386                XMLString::catString(fTempResult, PSVIUni::fgUnion);
1387        }
1388        if ((val & XSConstants::DERIVATION_SUBSTITUTION) != 0) {
1389                if (fTempResult && *fTempResult)
1390                        XMLString::catString(fTempResult, fgSpace);
1391                XMLString::catString(fTempResult, PSVIUni::fgSubstitution);
1392        }
1393        return fTempResult;
1394}
1395
1396const XMLCh* PSVIWriterHandlers::translateDerivationMethod(XSConstants::DERIVATION_TYPE derivation) {
1397        switch (derivation) {
1398                case XSConstants::DERIVATION_EXTENSION :
1399                        return PSVIUni::fgExtension;
1400                case XSConstants::DERIVATION_LIST :
1401                        return PSVIUni::fgList;
1402                case XSConstants::DERIVATION_RESTRICTION :
1403                        return PSVIUni::fgRestriction;
1404                case XSConstants::DERIVATION_SUBSTITUTION :
1405                        return PSVIUni::fgSubstitution;
1406                case XSConstants::DERIVATION_UNION :
1407                        return PSVIUni::fgUnion;
1408                case XSConstants::DERIVATION_NONE :
1409                        return NULL;
1410                default :
1411                        return PSVIUni::fgUnknown;
1412        }
1413}
1414
1415const XMLCh* PSVIWriterHandlers::translateProcessContents(XSWildcard::PROCESS_CONTENTS processContents) {
1416        switch (processContents) {
1417                case XSWildcard::PC_LAX :
1418                        return PSVIUni::fgLax;
1419                case XSWildcard::PC_SKIP :
1420                        return PSVIUni::fgSkip;
1421                case XSWildcard::PC_STRICT :
1422                        return PSVIUni::fgStrict;
1423                default :
1424                        return PSVIUni::fgUnknown;
1425        }
1426}
1427
1428const XMLCh* PSVIWriterHandlers::translateCompositor(XSModelGroup::COMPOSITOR_TYPE compositor) {
1429        switch (compositor) {
1430                case XSModelGroup::COMPOSITOR_SEQUENCE :
1431                        return PSVIUni::fgSequence;
1432                case XSModelGroup::COMPOSITOR_CHOICE :
1433                        return PSVIUni::fgChoice;
1434                case XSModelGroup::COMPOSITOR_ALL :
1435                        return PSVIUni::fgAll;
1436                default :
1437                        return PSVIUni::fgUnknown;
1438        }
1439}
1440
1441const XMLCh* PSVIWriterHandlers::translateValidity(PSVIItem::VALIDITY_STATE validity) {
1442        switch (validity) {
1443                case PSVIItem::VALIDITY_NOTKNOWN :
1444                        return PSVIUni::fgNotKnown;
1445                case PSVIItem::VALIDITY_VALID :
1446                        return PSVIUni::fgValid;
1447                case PSVIItem::VALIDITY_INVALID :
1448                        return PSVIUni::fgInvalid;
1449                default :
1450                        return PSVIUni::fgUnknown;
1451        }
1452}
1453
1454const XMLCh* PSVIWriterHandlers::translateValidationAttempted(PSVIItem::ASSESSMENT_TYPE validation) {
1455        switch (validation) {
1456                case PSVIItem::VALIDATION_NONE :
1457                        return PSVIUni::fgNone;
1458                case PSVIItem::VALIDATION_PARTIAL :
1459                        return PSVIUni::fgPartial;
1460                case PSVIItem::VALIDATION_FULL :
1461                        return PSVIUni::fgFull;
1462                default :
1463                        return PSVIUni::fgUnknown;
1464        }
1465}
1466
1467const XMLCh* PSVIWriterHandlers::translateIdConstraintCategory(XSIDCDefinition::IC_CATEGORY category) {
1468        switch (category) {
1469                case XSIDCDefinition::IC_KEY :
1470                        return PSVIUni::fgKey;
1471                case XSIDCDefinition::IC_KEYREF :
1472                        return PSVIUni::fgKeyref;
1473                case XSIDCDefinition::IC_UNIQUE :
1474                        return PSVIUni::fgUnique;
1475                default :
1476                        return PSVIUni::fgUnknown;
1477        }
1478}
1479
1480const XMLCh* PSVIWriterHandlers::translateComplexContentType(XSComplexTypeDefinition::CONTENT_TYPE contentType) {
1481        switch (contentType) {
1482                case XSComplexTypeDefinition::CONTENTTYPE_ELEMENT :
1483                        return PSVIUni::fgElementOnly;
1484                case XSComplexTypeDefinition::CONTENTTYPE_EMPTY :
1485                        return PSVIUni::fgEmpty;
1486                case XSComplexTypeDefinition::CONTENTTYPE_MIXED :
1487                        return PSVIUni::fgMixed;
1488                case XSComplexTypeDefinition::CONTENTTYPE_SIMPLE :
1489                        return PSVIUni::fgSimple;
1490                default :
1491                        return PSVIUni::fgUnknown;
1492        }
1493}
1494
1495const XMLCh* PSVIWriterHandlers::translateSimpleTypeVariety(XSSimpleTypeDefinition::VARIETY variety) {
1496        switch (variety) {
1497                case XSSimpleTypeDefinition::VARIETY_LIST :
1498                        return PSVIUni::fgList;
1499                case XSSimpleTypeDefinition::VARIETY_UNION :
1500                        return PSVIUni::fgUnion;
1501                case XSSimpleTypeDefinition::VARIETY_ATOMIC :
1502                        return PSVIUni::fgAtomic;
1503                case XSSimpleTypeDefinition::VARIETY_ABSENT :
1504                        return NULL;
1505                default :
1506                        return PSVIUni::fgUnknown;
1507        }
1508}
1509
1510const XMLCh* PSVIWriterHandlers::translateOrderedFacet(XSSimpleTypeDefinition::ORDERING ordered) {
1511        switch (ordered) {
1512                case XSSimpleTypeDefinition::ORDERED_FALSE:
1513                        return PSVIUni::fgFalse;
1514                case XSSimpleTypeDefinition::ORDERED_PARTIAL:
1515                        return PSVIUni::fgPartial;
1516                case XSSimpleTypeDefinition::ORDERED_TOTAL:
1517                        return PSVIUni::fgTotal;
1518                default :
1519                        return PSVIUni::fgUnknown;
1520        }
1521}
1522
1523const XMLCh* PSVIWriterHandlers::translateFacet(XSSimpleTypeDefinition::FACET facetKind) {
1524        switch (facetKind) {
1525                case XSSimpleTypeDefinition::FACET_WHITESPACE :
1526                        return PSVIUni::fgWhiteSpace;
1527                case XSSimpleTypeDefinition::FACET_LENGTH :
1528                        return PSVIUni::fgLength;
1529                case XSSimpleTypeDefinition::FACET_MINLENGTH :
1530                        return PSVIUni::fgMinLength;
1531                case XSSimpleTypeDefinition::FACET_MAXLENGTH :
1532                        return PSVIUni::fgMaxLength;
1533                case XSSimpleTypeDefinition::FACET_TOTALDIGITS :
1534                        return PSVIUni::fgTotalDigits;
1535                case XSSimpleTypeDefinition::FACET_FRACTIONDIGITS :
1536                        return PSVIUni::fgFractionDigits;
1537                case XSSimpleTypeDefinition::FACET_PATTERN :
1538                        return PSVIUni::fgPattern;
1539                case XSSimpleTypeDefinition::FACET_ENUMERATION :
1540                        return PSVIUni::fgEnumeration;
1541                case XSSimpleTypeDefinition::FACET_MAXINCLUSIVE :
1542                        return PSVIUni::fgMaxInclusive;
1543                case XSSimpleTypeDefinition::FACET_MAXEXCLUSIVE :
1544                        return PSVIUni::fgMaxExclusive;
1545                case XSSimpleTypeDefinition::FACET_MINEXCLUSIVE :
1546                        return PSVIUni::fgMinExclusive;
1547                case XSSimpleTypeDefinition::FACET_MININCLUSIVE :
1548                        return PSVIUni::fgMinInclusive;
1549                default :
1550                        return PSVIUni::fgUnknown;
1551        }
1552}
1553
1554const XMLCh* PSVIWriterHandlers::translateComponentType(XSConstants::COMPONENT_TYPE type) {
1555        switch (type) {
1556                case XSConstants::TYPE_DEFINITION :
1557                        return PSVIUni::fgType;
1558                case XSConstants::ANNOTATION :
1559                        return PSVIUni::fgAnnot;
1560                case XSConstants::ATTRIBUTE_DECLARATION :
1561                        return PSVIUni::fgAttr;
1562                case XSConstants::ATTRIBUTE_GROUP_DEFINITION :
1563                        return PSVIUni::fgAg;
1564                case XSConstants::ATTRIBUTE_USE :
1565                        return PSVIUni::fgAu;
1566                case XSConstants::ELEMENT_DECLARATION :
1567                        return PSVIUni::fgElt;
1568                case XSConstants::MODEL_GROUP_DEFINITION :
1569                        return PSVIUni::fgMg;
1570                case XSConstants::NOTATION_DECLARATION :
1571                        return PSVIUni::fgNot;
1572                case XSConstants::IDENTITY_CONSTRAINT :
1573                        return PSVIUni::fgIdc;
1574                default :
1575                        return PSVIUni::fgUnknown;
1576        }
1577}
1578
1579const XMLCh* PSVIWriterHandlers::translateBool(bool flag) {
1580        return (flag ? PSVIUni::fgTrue : PSVIUni::fgFalse);
1581}
1582
1583XMLCh* PSVIWriterHandlers::createID(XSObject* obj) {
1584        const XMLCh* objPrefix = fPrefixMap->get(obj->getNamespace());
1585        XMLCh* result = new XMLCh[100];
1586
1587        if (XMLString::equals(obj->getNamespace(), PSVIUni::fgNamespaceXmlSchema)) {
1588                        XMLString::copyString(result, obj->getName());
1589        } else {
1590                const XMLCh period[] = { chPeriod, chNull };
1591                XMLCh anonNum[6];
1592                bool hasPrefix = objPrefix!=NULL && *objPrefix!=0;
1593                if (hasPrefix) {
1594                        XMLString::copyString(result, objPrefix);
1595                        XMLString::catString(result, period);
1596                        XMLString::catString(result, translateComponentType(obj->getType()));
1597                } else {
1598                        XMLString::copyString(result, translateComponentType(obj->getType()));
1599                }
1600                XMLString::catString(result, period);
1601
1602                if (obj->getType()==XSConstants::TYPE_DEFINITION && ((XSTypeDefinition*)obj)->getAnonymous()) {
1603                        const XMLCh anon[] = { chLatin_a, chLatin_n, chLatin_o, chLatin_n, chUnderscore, chNull };
1604                        XMLString::catString(result, anon);
1605                        XMLString::binToText(fAnonNum, anonNum, 5, 10);
1606                        XMLString::catString(result, anonNum);
1607                        fAnonNum++;
1608                } else {
1609                        XMLString::catString(result, obj->getName());
1610                        if (!hasPrefix) {
1611                                XMLString::catString(result, period);
1612                                XMLString::binToText(fAnonNum, anonNum, 5, 10);
1613                                XMLString::catString(result, anonNum);
1614                                fAnonNum++;
1615                        }
1616                }
1617        }
1618        fIdNames->addElement(result);
1619        return result;
1620}
1621
1622const XMLCh* PSVIWriterHandlers::getIdName(XSObject* obj) {
1623        XMLCh* objLoc = new XMLCh[9];
1624        XMLString::sizeToText((XMLSize_t)obj, objLoc, 8, 16);
1625        XMLCh* idName = fIdMap->get(objLoc);
1626        if (!idName) {
1627                idName = createID(obj);
1628                fIdMap->put(objLoc, idName);
1629                fObjectLocations->addElement(objLoc);
1630        } else {
1631                delete objLoc;
1632        }
1633        return idName;
1634}
1635
1636void PSVIWriterHandlers::incIndent() {
1637    XMLCh tab[] = {chHTab, chNull};
1638    if (fIndent >= fIndentCap) {
1639        fIndentCap *= 2;
1640        XMLCh* temp = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate((fIndentCap+1)*sizeof(XMLCh));
1641        XMLString::copyString(temp, fIndentChars);
1642        XMLPlatformUtils::fgMemoryManager->deallocate(fIndentChars);
1643        fIndentChars = temp;
1644    }
1645    XMLString::catString(fIndentChars, tab);
1646    fIndent++;
1647}
1648
1649void PSVIWriterHandlers::decIndent() {
1650        fIndentChars[XMLString::stringLen(fIndentChars)-1] = chNull;
1651        fIndent--;
1652}
1653
1654/***
1655 *    yyyy-mm-ddThh:mm:ss.sssss
1656 ***/
1657void PSVIWriterHandlers::formDateTime(XSValue* obj)
1658{
1659
1660    char buffer[1024];
1661    memset(buffer, 0, sizeof buffer);
1662    sprintf(buffer, "%d-%d-%dT%d:%d:%f", obj->fData.fValue.f_datetime.f_year
1663                                       , obj->fData.fValue.f_datetime.f_month
1664                                       , obj->fData.fValue.f_datetime.f_day
1665                                       , obj->fData.fValue.f_datetime.f_hour
1666                                       , obj->fData.fValue.f_datetime.f_min
1667                                       , obj->fData.fValue.f_datetime.f_second
1668                                       + obj->fData.fValue.f_datetime.f_milisec);
1669
1670    XMLCh *value = XMLString::transcode(buffer);
1671    ArrayJanitor<XMLCh> jan(value);
1672    writeValue(gDataValue, value);
1673}
1674
1675/***
1676 *  <actualValue>
1677 *       <dataType>unsignedShort</dataType>
1678 *           <dataValue>0</dataValue>
1679 *      </actualValue>
1680 ***/
1681void  PSVIWriterHandlers::processActualValue(PSVIItem* item)
1682{
1683    if (!item) return;
1684
1685    XSValue* obj = item->getActualValue();
1686
1687    if (obj)
1688    {
1689        char buffer[1024];
1690
1691        writeString(gCommentStart);
1692        incIndent();
1693        writeOpen(gActualValue);
1694        incIndent();
1695
1696        switch (obj->fData.f_datatype)
1697        {
1698        case XSValue::dt_boolean:
1699            {
1700                writeValue(gDataType, SchemaSymbols::fgDT_BOOLEAN);
1701                writeValue(gDataValue, XMLUni::fgBooleanValueSpace[obj->fData.fValue.f_bool? 0: 1]);
1702            }
1703            break;
1704        case XSValue::dt_decimal:
1705            {
1706                writeValue(gDataType, SchemaSymbols::fgDT_DECIMAL);
1707                sprintf( buffer,"%f", obj->fData.fValue.f_decimal.f_dvalue);
1708                XMLCh *value = XMLString::transcode(buffer);
1709                ArrayJanitor<XMLCh> jan(value);
1710                writeValue(gDataValue, value);
1711            }
1712            break;
1713        case XSValue::dt_float:
1714            {
1715                writeValue(gDataType, SchemaSymbols::fgDT_FLOAT);
1716                sprintf( buffer,"%f", obj->fData.fValue.f_float);
1717                XMLCh *value = XMLString::transcode(buffer);
1718                ArrayJanitor<XMLCh> jan(value);
1719                writeValue(gDataValue, value);
1720            }
1721            break;
1722        case XSValue::dt_double:
1723            {
1724                writeValue(gDataType, SchemaSymbols::fgDT_DOUBLE);
1725                sprintf( buffer,"%f", obj->fData.fValue.f_double);
1726                XMLCh *value = XMLString::transcode(buffer);
1727                ArrayJanitor<XMLCh> jan(value);
1728                writeValue(gDataValue, value);
1729            }
1730            break;
1731        case XSValue::dt_duration:
1732            {
1733                writeValue(gDataType, SchemaSymbols::fgDT_DURATION);
1734                formDateTime(obj);
1735            }
1736            break;
1737        case XSValue::dt_dateTime:
1738            {
1739                writeValue(gDataType, SchemaSymbols::fgDT_DATETIME);
1740                formDateTime(obj);
1741            }
1742            break;
1743        case XSValue::dt_time:
1744            {
1745                writeValue(gDataType, SchemaSymbols::fgDT_TIME);
1746                formDateTime(obj);
1747            }
1748            break;
1749        case XSValue::dt_date:
1750            {
1751                writeValue(gDataType, SchemaSymbols::fgDT_DATE);
1752                formDateTime(obj);
1753            }
1754            break;
1755        case XSValue::dt_gYearMonth:
1756            {
1757                writeValue(gDataType, SchemaSymbols::fgDT_YEARMONTH);
1758                formDateTime(obj);
1759            }
1760            break;
1761        case XSValue::dt_gYear:
1762            {
1763                writeValue(gDataType, SchemaSymbols::fgDT_YEAR);
1764                formDateTime(obj);
1765            }
1766            break;
1767        case XSValue::dt_gMonthDay:
1768            {
1769                writeValue(gDataType, SchemaSymbols::fgDT_MONTHDAY);
1770                formDateTime(obj);
1771            }
1772            break;
1773        case XSValue::dt_gDay:
1774            {
1775                writeValue(gDataType, SchemaSymbols::fgDT_DAY);
1776                formDateTime(obj);
1777            }
1778            break;
1779        case XSValue::dt_gMonth:
1780            {
1781                writeValue(gDataType, SchemaSymbols::fgDT_MONTH);
1782                formDateTime(obj);
1783            }
1784            break;
1785        case XSValue::dt_hexBinary:
1786            {
1787                writeValue(gDataType, SchemaSymbols::fgDT_HEXBINARY);
1788                writeValue(gDataValue, obj->fData.fValue.f_strVal);
1789            }
1790            break;
1791        case XSValue::dt_base64Binary:
1792            {
1793                writeValue(gDataType, SchemaSymbols::fgDT_BASE64BINARY);
1794                writeValue(gDataValue, obj->fData.fValue.f_strVal);
1795            }
1796            break;
1797
1798        case XSValue::dt_integer:
1799            {
1800                writeValue(gDataType, SchemaSymbols::fgDT_INTEGER);
1801                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1802                XMLCh *value = XMLString::transcode(buffer);
1803                ArrayJanitor<XMLCh> jan(value);
1804                writeValue(gDataValue, value);
1805            }
1806            break;
1807        case XSValue::dt_nonPositiveInteger:
1808            {
1809                writeValue(gDataType, SchemaSymbols::fgDT_NONPOSITIVEINTEGER);
1810                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1811                XMLCh *value = XMLString::transcode(buffer);
1812                ArrayJanitor<XMLCh> jan(value);
1813                writeValue(gDataValue, value);
1814            }
1815            break;
1816        case XSValue::dt_negativeInteger:
1817            {
1818                writeValue(gDataType, SchemaSymbols::fgDT_NEGATIVEINTEGER);
1819                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1820                XMLCh *value = XMLString::transcode(buffer);
1821                ArrayJanitor<XMLCh> jan(value);
1822                writeValue(gDataValue, value);
1823            }
1824            break;
1825        case XSValue::dt_long:
1826            {
1827                writeValue(gDataType, SchemaSymbols::fgDT_LONG);
1828                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1829                XMLCh *value = XMLString::transcode(buffer);
1830                ArrayJanitor<XMLCh> jan(value);
1831                writeValue(gDataValue, value);
1832            }
1833            break;
1834        case XSValue::dt_int:
1835            {
1836                writeValue(gDataType, SchemaSymbols::fgDT_INT);
1837                sprintf( buffer,"%d", obj->fData.fValue.f_int);
1838                XMLCh *value = XMLString::transcode(buffer);
1839                ArrayJanitor<XMLCh> jan(value);
1840                writeValue(gDataValue, value);
1841            }
1842            break;
1843        case XSValue::dt_short:
1844            {
1845                writeValue(gDataType, SchemaSymbols::fgDT_SHORT);
1846                sprintf( buffer,"%d", obj->fData.fValue.f_short);
1847                XMLCh *value = XMLString::transcode(buffer);
1848                ArrayJanitor<XMLCh> jan(value);
1849                writeValue(gDataValue, value);
1850            }
1851            break;
1852        case XSValue::dt_byte:
1853            {
1854                writeValue(gDataType, SchemaSymbols::fgDT_BYTE);
1855                sprintf( buffer,"%d", obj->fData.fValue.f_char);
1856                XMLCh *value = XMLString::transcode(buffer);
1857                ArrayJanitor<XMLCh> jan(value);
1858                writeValue(gDataValue, value);
1859            }
1860            break;
1861        case XSValue::dt_nonNegativeInteger:
1862            {
1863                writeValue(gDataType, SchemaSymbols::fgDT_NONNEGATIVEINTEGER);
1864                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1865                XMLCh *value = XMLString::transcode(buffer);
1866                ArrayJanitor<XMLCh> jan(value);
1867                writeValue(gDataValue, value);
1868            }
1869            break;
1870        case XSValue::dt_unsignedLong:
1871            {
1872                writeValue(gDataType, SchemaSymbols::fgDT_ULONG);
1873                sprintf( buffer,"%lu", obj->fData.fValue.f_ulong);
1874                XMLCh *value = XMLString::transcode(buffer);
1875                ArrayJanitor<XMLCh> jan(value);
1876                writeValue(gDataValue, value);
1877            }
1878            break;
1879        case XSValue::dt_unsignedInt:
1880            {
1881                writeValue(gDataType, SchemaSymbols::fgDT_UINT);
1882                sprintf( buffer,"%u", obj->fData.fValue.f_uint);
1883                XMLCh *value = XMLString::transcode(buffer);
1884                ArrayJanitor<XMLCh> jan(value);
1885                writeValue(gDataValue, value);
1886            }
1887            break;
1888        case XSValue::dt_unsignedShort:
1889            {
1890                writeValue(gDataType, SchemaSymbols::fgDT_USHORT);
1891                sprintf( buffer,"%u", obj->fData.fValue.f_ushort);
1892                XMLCh *value = XMLString::transcode(buffer);
1893                ArrayJanitor<XMLCh> jan(value);
1894                writeValue(gDataValue, value);
1895            }
1896            break;
1897        case XSValue::dt_unsignedByte:
1898            {
1899                writeValue(gDataType, SchemaSymbols::fgDT_UBYTE);
1900                sprintf( buffer,"%u", obj->fData.fValue.f_uchar);
1901                XMLCh *value = XMLString::transcode(buffer);
1902                ArrayJanitor<XMLCh> jan(value);
1903                writeValue(gDataValue, value);
1904            }
1905            break;
1906        case XSValue::dt_positiveInteger:
1907            {
1908                writeValue(gDataType, SchemaSymbols::fgDT_POSITIVEINTEGER);
1909                sprintf( buffer,"%ld", obj->fData.fValue.f_long);
1910                XMLCh *value = XMLString::transcode(buffer);
1911                ArrayJanitor<XMLCh> jan(value);
1912                writeValue(gDataValue, value);
1913            }
1914            break;
1915        case XSValue::dt_string:
1916        case XSValue::dt_anyURI:
1917        case XSValue::dt_QName:
1918        case XSValue::dt_NOTATION:
1919        case XSValue::dt_normalizedString:
1920        case XSValue::dt_token:
1921        case XSValue::dt_language:
1922        case XSValue::dt_NMTOKEN:
1923        case XSValue::dt_NMTOKENS:
1924        case XSValue::dt_Name:
1925        case XSValue::dt_NCName:
1926        case XSValue::dt_ID:
1927        case XSValue::dt_IDREF:
1928        case XSValue::dt_IDREFS:
1929        case XSValue::dt_ENTITY:
1930        case XSValue::dt_ENTITIES:
1931            break; //we shouldn't see them
1932        default:
1933            break;
1934        }
1935
1936        decIndent();
1937        writeClose(gActualValue);
1938        decIndent();
1939        writeString(gCommentEnd);
1940
1941        delete obj;
1942        }
1943}
1944
1945void PSVIAdvancedHandler::XMLDecl(const XMLCh* const versionStr, const XMLCh* const encodingStr, const XMLCh* const standaloneStr, const XMLCh* const autoEncodingStr)
1946{
1947    if (encodingStr && *encodingStr)
1948        fWriterHandler->sendElementValue(PSVIUni::fgCharacterEncodingScheme, encodingStr);
1949    else
1950        fWriterHandler->sendElementValue(PSVIUni::fgCharacterEncodingScheme, autoEncodingStr);
1951    if (standaloneStr && *standaloneStr)
1952        fWriterHandler->sendElementValue(PSVIUni::fgStandalone, standaloneStr);
1953        else
1954        fWriterHandler->sendElementEmpty(PSVIUni::fgStandalone);
1955        fWriterHandler->sendElementValue(PSVIUni::fgVersion, versionStr);
1956}
Note: See TracBrowser for help on using the repository browser.