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

Last change on this file since 3583 was 3583, checked in by nmedfort, 5 years ago

more compile fixes

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