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