/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package xni; import java.io.IOException; import java.util.ArrayList; import java.util.Enumeration; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Stack; import org.apache.xerces.dom.DocumentImpl; import org.apache.xerces.impl.Constants; import org.apache.xerces.impl.xs.SchemaSymbols; import org.apache.xerces.util.DOMUtil; import org.apache.xerces.util.NamespaceSupport; import org.apache.xerces.util.XMLAttributesImpl; import org.apache.xerces.util.XMLSymbols; import org.apache.xerces.xni.Augmentations; import org.apache.xerces.xni.NamespaceContext; import org.apache.xerces.xni.QName; import org.apache.xerces.xni.XMLAttributes; import org.apache.xerces.xni.XMLDocumentHandler; import org.apache.xerces.xni.XMLLocator; import org.apache.xerces.xni.XMLResourceIdentifier; import org.apache.xerces.xni.XMLString; import org.apache.xerces.xni.XNIException; import org.apache.xerces.xni.parser.XMLComponent; import org.apache.xerces.xni.parser.XMLComponentManager; import org.apache.xerces.xni.parser.XMLConfigurationException; import org.apache.xerces.xni.parser.XMLDocumentFilter; import org.apache.xerces.xni.parser.XMLDocumentSource; import org.apache.xerces.xs.AttributePSVI; import org.apache.xerces.xs.ElementPSVI; import org.apache.xerces.xs.ItemPSVI; import org.apache.xerces.xs.StringList; import org.apache.xerces.xs.XSAnnotation; import org.apache.xerces.xs.XSAttributeDeclaration; import org.apache.xerces.xs.XSAttributeGroupDefinition; import org.apache.xerces.xs.XSAttributeUse; import org.apache.xerces.xs.XSComplexTypeDefinition; import org.apache.xerces.xs.XSConstants; import org.apache.xerces.xs.XSElementDeclaration; import org.apache.xerces.xs.XSFacet; import org.apache.xerces.xs.XSIDCDefinition; import org.apache.xerces.xs.XSModel; import org.apache.xerces.xs.XSModelGroup; import org.apache.xerces.xs.XSModelGroupDefinition; import org.apache.xerces.xs.XSMultiValueFacet; import org.apache.xerces.xs.XSNamedMap; import org.apache.xerces.xs.XSNamespaceItem; import org.apache.xerces.xs.XSNamespaceItemList; import org.apache.xerces.xs.XSNotationDeclaration; import org.apache.xerces.xs.XSObject; import org.apache.xerces.xs.XSObjectList; import org.apache.xerces.xs.XSParticle; import org.apache.xerces.xs.XSSimpleTypeDefinition; import org.apache.xerces.xs.XSTypeDefinition; import org.apache.xerces.xs.XSValue; import org.apache.xerces.xs.XSWildcard; import org.w3c.dom.Attr; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.xml.sax.SAXNotRecognizedException; import org.xml.sax.SAXNotSupportedException; /** * This class is a intersepts XNI events and serialized * XML infoset and Post Schema Validation Infoset. * * @author Arun Yadav,Sun Miscrosystem. * @author Peter McCracken, IBM * @version $Id$ */ public class PSVIWriter implements XMLComponent, XMLDocumentFilter { public static final String XERCES_PSVI_NS = "http://apache.org/xml/2001/PSVInfosetExtension"; /** Feature id: augment Post-Schema-Validation-Infoset */ protected static final String PSVINFOSET = Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_AUGMENT_PSVI; /** Feature id: include ignorable whitespace. */ protected static final String INCLUDE_IGNORABLE_WHITESPACE = "http://apache.org/xml/features/dom/include-ignorable-whitespace"; /** Include ignorable whitespace. */ protected boolean fIncludeIgnorableWhitespace; /** Recognized features. */ private static final String[] RECOGNIZED_FEATURES = { INCLUDE_IGNORABLE_WHITESPACE, PSVINFOSET, }; /** Feature defaults. */ private static final Boolean[] FEATURE_DEFAULTS = { null, null, }; /** Recognized properties. */ private static final String[] RECOGNIZED_PROPERTIES = { }; /** Property defaults. */ private static final Object[] PROPERTY_DEFAULTS = { }; /** PSVInfoset */ protected boolean fPSVInfoset; /** Document handler. */ protected XMLDocumentHandler fDocumentHandler; /** Document source */ protected XMLDocumentSource fDocumentSource; /** The namespace context for the received event stream */ protected NamespaceContext fNamespaceContext; /** The namespace context for the new event stream */ protected NamespaceContext fPSVINamespaceContext; /** Document Location */ protected XMLLocator fDocumentLocation; /** Attributes and Element Info is cached in stack */ private Stack _elementState = new Stack(); /** The number used for anonymous types */ protected int fAnonNum; /** The number that stores the indent level */ protected int fIndent; /** The map used to store IDs for types and elements */ protected Map fIDMap; /** A list of ids for defined XSObjects */ protected List fDefined; private char[] fIndentChars = { '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t' }; private XMLString newLine = new XMLString(new char[] { '\n' }, 0, 1); public PSVIWriter() { /* System.out.println( "Generating Schema Information Set Contribution (PSVI) \n" + "which follow as a consequence of validation and/or assessment."); System.out.println("NOTE: Requires use of -s and -v"); System.out.println("Output: generated in " + PSVI_OUTPUT); */ } // () public void reset(XMLComponentManager componentManager) throws XNIException { try { fPSVInfoset = componentManager.getFeature(PSVINFOSET); } catch (XMLConfigurationException e) { fPSVInfoset = false; } fIncludeIgnorableWhitespace = componentManager.getFeature(INCLUDE_IGNORABLE_WHITESPACE); fAnonNum = 1000; fIDMap = new HashMap(); fDefined = new ArrayList(); fIndent = 0; fPSVINamespaceContext = new NamespaceSupport(); } // reset(XMLComponentManager) /** * Returns a list of feature identifiers that are recognized by * this component. This method may return null if no features * are recognized by this component. */ public String[] getRecognizedFeatures() { return RECOGNIZED_FEATURES; } // getRecognizedFeatures():String[] /** * Sets the state of a feature. This method is called by the component * manager any time after reset when a feature changes state. *

* Note: Components should silently ignore features * that do not affect the operation of the component. * * @param featureId The feature identifier. * @param state The state of the feature. * * @throws SAXNotRecognizedException The component should not throw * this exception. * @throws SAXNotSupportedException The component should not throw * this exception. */ public void setFeature(String featureId, boolean state) throws XMLConfigurationException { } // setFeature(String,boolean) /** * Returns a list of property identifiers that are recognized by * this component. This method may return null if no properties * are recognized by this component. */ public String[] getRecognizedProperties() { return RECOGNIZED_PROPERTIES; } // getRecognizedProperties():String[] /** * Sets the value of a property. This method is called by the component * manager any time after reset when a property changes value. *

* Note: Components should silently ignore properties * that do not affect the operation of the component. * * @param propertyId The property identifier. * @param value The value of the property. * * @throws SAXNotRecognizedException The component should not throw * this exception. * @throws SAXNotSupportedException The component should not throw * this exception. */ public void setProperty(String propertyId, Object value) throws XMLConfigurationException { } // setProperty(String,Object) /** * Returns the default state for a feature, or null if this * component does not want to report a default value for this * feature. * * @param featureId The feature identifier. * * @since Xerces 2.2.0 */ public Boolean getFeatureDefault(String featureId) { for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) { if (RECOGNIZED_FEATURES[i].equals(featureId)) { return FEATURE_DEFAULTS[i]; } } return null; } // getFeatureDefault(String):Boolean /** * Returns the default state for a property, or null if this * component does not want to report a default value for this * property. * * @param propertyId The property identifier. * * @since Xerces 2.2.0 */ public Object getPropertyDefault(String propertyId) { for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) { if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) { return PROPERTY_DEFAULTS[i]; } } return null; } // getPropertyDefault(String):Object // // XMLDocumentSource methods // /** Sets the document handler to receive information about the document. */ public void setDocumentHandler(XMLDocumentHandler documentHandler) { fDocumentHandler = documentHandler; } // setDocumentHandler(XMLDocumentHandler) /** Returns the document handler */ public XMLDocumentHandler getDocumentHandler() { return fDocumentHandler; } // setDocumentHandler(XMLDocumentHandler) // // XMLDocumentHandler methods // /** Sets the document source */ public void setDocumentSource(XMLDocumentSource source) { fDocumentSource = source; } // setDocumentSource /** Returns the document source */ public XMLDocumentSource getDocumentSource() { return fDocumentSource; } // getDocumentSource /** * This method notifies the start of an entity. General entities are just * specified by their name. *

* Note: This method is not called for entity references * appearing as part of attribute values. * * @param name The name of the entity. * @param publicId The public identifier of the entity if the entity * is external, null otherwise. * @param systemId The system identifier of the entity if the entity * is external, null otherwise. * @param baseSystemId The base system identifier of the entity if * the entity is external, null otherwise. * @param encoding The auto-detected IANA encoding name of the entity * stream. This value will be null in those situations * where the entity encoding is not auto-detected (e.g. * internal entities or a document entity that is * parsed from a java.io.Reader). * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void startGeneralEntity( String name, XMLResourceIdentifier identifier, String encoding, Augmentations augs) throws XNIException { } // startEntity(String,String,String,String,String) /** * Notifies of the presence of a TextDecl line in an entity. If present, * this method will be called immediately following the startEntity call. *

* Note: This method will never be called for the * document entity; it is only called for external general entities * referenced in document content. *

* Note: This method is not called for entity references * appearing as part of attribute values. * * @param version The XML version, or null if not specified. * @param encoding The IANA encoding name of the entity. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void textDecl(String version, String encoding, Augmentations augs) throws XNIException { } // textDecl(String,String) /** * The start of the document. * @throws XNIException Thrown by handler to signal an error. */ public void startDocument( XMLLocator locator, String encoding, NamespaceContext namespaceContext, Augmentations augs) throws XNIException { fNamespaceContext = namespaceContext; fDocumentLocation = locator; fPSVINamespaceContext.declarePrefix( "xsi", "http://www.w3.org/2001/XMLSchema-instance"); fPSVINamespaceContext.declarePrefix("psv", XERCES_PSVI_NS); fPSVINamespaceContext.declarePrefix( "", "http://www.w3.org/2001/05/XMLInfoset"); if (fDocumentHandler == null) return; fDocumentHandler.startDocument( locator, "UTF-8", fPSVINamespaceContext, null); List attributes = new ArrayList(); attributes.add("xmlns:xsi"); attributes.add("http://www.w3.org/2001/XMLSchema-instance"); attributes.add(XMLSymbols.fCDATASymbol); attributes.add("xmlns:psv"); attributes.add(XERCES_PSVI_NS); attributes.add(XMLSymbols.fCDATASymbol); attributes.add("xmlns"); attributes.add("http://www.w3.org/2001/05/XMLInfoset"); attributes.add(XMLSymbols.fCDATASymbol); sendIndentedElement("document", attributes); } // startDocument(XMLLocator,String) /** * Notifies of the presence of an XMLDecl line in the document. If * present, this method will be called immediately following the * startDocument call. * * @param version The XML version. * @param encoding The IANA encoding name of the document, or null if * not specified. * @param standalone The standalone value, or null if not specified. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void xmlDecl( String version, String encoding, String standalone, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; sendElementEvent("characterEncodingScheme", encoding); sendElementEvent("standalone", standalone); sendElementEvent("version", version); } // xmlDecl(String,String,String) /** * Notifies of the presence of the DOCTYPE line in the document. * * @param rootElement The name of the root element. * @param publicId The public identifier if an external DTD or null * if the external DTD is specified using SYSTEM. * @param systemId The system identifier if an external DTD, null * otherwise. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void doctypeDecl( String rootElement, String publicId, String systemId, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); sendIndentedElement("docTypeDeclaration"); if (publicId != null) sendElementEvent("publicIdentifier", publicId); if (systemId != null) sendElementEvent("systemIdentifier", systemId); sendUnIndentedElement("docTypeDeclaration"); } // doctypeDecl(String,String,String) /** * A comment. * * @param text The text in the comment. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by application to signal an error. */ public void comment(XMLString text, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); sendIndentedElement("comment"); sendElementEvent("content", text); sendUnIndentedElement("comment"); } // comment(XMLString) /** * A processing instruction. Processing instructions consist of a * target name and, optionally, text data. The data is only meaningful * to the application. *

* Typically, a processing instruction's data will contain a series * of pseudo-attributes. These pseudo-attributes follow the form of * element attributes but are not parsed or presented * to the application as anything other than text. The application is * responsible for parsing the data. * * @param target The target. * @param data The data or null if none specified. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void processingInstruction( String target, XMLString data, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); sendIndentedElement("processingInstruction"); sendElementEvent("target", target); sendElementEvent("content", data); sendUnIndentedElement("processingInstruction"); } // processingInstruction(String,XMLString) /** * Binds the namespaces. This method will handle calling the * document handler to start the prefix mappings. *

* Note: This method makes use of the * fAttributeQName variable. Any contents of the variable will * be destroyed. Caller should copy the values out of this * temporary variable before calling this method. * * @param element The name of the element. * @param attributes The element attributes. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void startElement( QName element, XMLAttributes attributes, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); _elementState.push(new ElementState(true)); sendIndentedElement("element"); sendElementEvent("namespaceName", element.uri); sendElementEvent("localName", element.localpart); sendElementEvent("prefix", element.prefix); processAttributes(attributes); processInScopeNamespaces(); sendElementEvent("baseURI", fDocumentLocation.getBaseSystemId()); if (fPSVInfoset) { processPSVIStartElement(augs); } } // startElement(QName,XMLAttributes) /** * An empty element. * * @param element The name of the element. * @param attributes The element attributes. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void emptyElement( QName element, XMLAttributes attributes, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); sendIndentedElement("element"); sendElementEvent("namespaceName", element.uri); sendElementEvent("localName", element.localpart); sendElementEvent("prefix", element.prefix); processAttributes(attributes); processInScopeNamespaces(); sendElementEvent("baseURI", fDocumentLocation.getBaseSystemId()); if (fPSVInfoset) { processPSVIStartElement(augs); } sendEmptyElementEvent("children"); if (fPSVInfoset) { processPSVIEndElement(augs); } sendUnIndentedElement("element"); } // emptyElement(QName,XMLAttributes) /** * Character content. * * @param text The content. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void characters(XMLString text, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; checkForChildren(); sendIndentedElement("character"); sendElementEvent("textContent", text); // detecting whitespace is not relevant here // this is only useful if characters are output individually sendUnIndentedElement("character"); } // characters(XMLString) /** * Ignorable whitespace. For this method to be called, the document * source must have some way of determining that the text containing * only whitespace characters should be considered ignorable. For * example, the validator can determine if a length of whitespace * characters in the document are ignorable based on the element * content model. * * @param text The ignorable whitespace. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; if (fIncludeIgnorableWhitespace) { this.characters(text, augs); } } // ignorableWhitespace(XMLString) /** * The end of an element. * * @param element The name of the element. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void endElement(QName element, Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; ElementState fElementState = (ElementState)_elementState.peek(); if (fElementState.isEmpty) { sendEmptyElementEvent("children"); } else { sendUnIndentedElement("children"); } _elementState.pop(); if (fPSVInfoset) { processPSVIStartElement(augs); processPSVIEndElement(augs); } sendUnIndentedElement("element"); } // endElement(QName) /** * The start of a CDATA section. * * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void startCDATA(Augmentations augs) throws XNIException { } // startCDATA() /** * The end of a CDATA section. * * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void endCDATA(Augmentations augs) throws XNIException { } // endCDATA() /** * The end of the document. * * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void endDocument(Augmentations augs) throws XNIException { if (fDocumentHandler == null) return; sendUnIndentedElement("children"); sendElementEvent("documentElement"); // these aren't relevent for PSVI sendEmptyElementEvent("notations"); sendEmptyElementEvent("unparsedEntities"); sendElementEvent("baseURI", fDocumentLocation.getBaseSystemId()); // do we ALWAYS process all declarations? I think so - PJM // this isn't relevant to PSVI sendElementEvent("allDeclarationsProcessed", "true"); sendUnIndentedElement("document"); fDocumentHandler.endDocument(null); } // endDocument() /** * This method notifies the end of an entity. General entities are just * specified by their name. *

* Note: This method is not called for entity references * appearing as part of attribute values. * * @param name The name of the entity. * @param augs Additional information that may include infoset augmentations * * @throws XNIException Thrown by handler to signal an error. */ public void endGeneralEntity(String name, Augmentations augs) throws XNIException { } // endEntity(String) /** * Write an unordered set of attribute information items, one for each of * the attributes (specified or defaulted from the DTD) of this element. * Namespace declarations do not appear in this set. If the element has no * attributes, this set has no members. */ private void processAttributes(XMLAttributes attributes) { boolean namespaceAttribute = false; boolean attrElement = false; int attrCount = attributes == null ? 0 : attributes.getLength(); if (attrCount == 0) { sendEmptyElementEvent("attributes"); sendEmptyElementEvent("namespaceAttributes"); return; } for (int i = 0; i < attrCount; i++) { String localpart = attributes.getLocalName(i); String prefix = attributes.getPrefix(i); if (prefix.equals(XMLSymbols.PREFIX_XMLNS) || localpart.equals(XMLSymbols.PREFIX_XMLNS)) { namespaceAttribute = true; continue; } if (!attrElement) sendIndentedElement("attributes"); sendIndentedElement("attribute"); sendElementEvent("namespaceName", attributes.getURI(i)); sendElementEvent("localName", attributes.getLocalName(i)); sendElementEvent("prefix", attributes.getPrefix(i)); sendElementEvent("normalizedValue", attributes.getValue(i)); sendElementEvent( "specified", String.valueOf(attributes.isSpecified(i))); sendElementEvent("attributeType", attributes.getType(i)); // this property isn't relevent to PSVI sendElementEvent("references"); if (fPSVInfoset) { processPSVIAttribute(attributes.getAugmentations(i)); } sendUnIndentedElement("attribute"); attrElement = true; } if (attrElement) { sendUnIndentedElement("attributes"); } else { sendEmptyElementEvent("attributes"); } if (namespaceAttribute) { processNamespaceAttributes(attributes); } else { sendEmptyElementEvent("namespaceAttributes"); } } //printAttributes /** * Write an unordered set of attribute information items, one for each of * the namespace declarations (specified or defaulted from the DTD) of this * element. A declaration of the form xmlns="", which undeclares the default * namespace, counts as a namespace declaration. By definition, all * namespace attributes (including those named xmlns, whose [prefix] * property has no value) have a namespace URI of * http://www.w3.org/2000/xmlns/. If the element has no namespace * declarations, this set has no members */ private void processNamespaceAttributes(XMLAttributes attributes) { // we don't need to check for null, since that was checked for in processAttributes() int attrCount = attributes.getLength(); sendIndentedElement("namespaceAttributes"); for (int i = 0; i < attrCount; i++) { String localpart = attributes.getLocalName(i); String prefix = attributes.getPrefix(i); if (!(prefix.equals(XMLSymbols.PREFIX_XMLNS) || localpart.equals(XMLSymbols.PREFIX_XMLNS))) continue; sendIndentedElement("attribute"); sendElementEvent("namespaceName", NamespaceContext.XMLNS_URI); sendElementEvent("localName", localpart); sendElementEvent("prefix", prefix); sendElementEvent("normalizedValue", attributes.getValue(i)); sendElementEvent( "specified", String.valueOf(attributes.isSpecified(i))); sendElementEvent("attributeType", attributes.getType(i)); // this property isn't relevent to PSVI sendElementEvent("references"); if (fPSVInfoset) { processPSVIAttribute(attributes.getAugmentations(i)); } sendUnIndentedElement("attribute"); } sendUnIndentedElement("namespaceAttributes"); } //printNamespacesAttributes() /** * Write an unordered set of namespace information items, one for each of the * namespaces in effect for this element. This set always contains an item * with the prefix xml which is implicitly bound to the namespace name * http://www.w3.org/XML/1998/namespace. It does not contain an item with the * prefix xmlns (used for declaring namespaces), since an application can * never encounter an element or attribute with that prefix. The set will * include namespace items corresponding to all of the members of * [namespace attributes], except for any representing a declaration of the * form xmlns="", which does not declare a namespace but rather undeclares * the default namespace */ private void processInScopeNamespaces() { sendIndentedElement("inScopeNamespaces"); sendIndentedElement("namespace"); // print 'xml' binding sendElementEvent("prefix", "xml"); sendElementEvent("namespaceName", NamespaceContext.XML_URI); sendUnIndentedElement("namespace"); Enumeration prefixes = fNamespaceContext.getAllPrefixes(); while (prefixes.hasMoreElements()) { sendIndentedElement("namespace"); String prefix = (String)prefixes.nextElement(); String uri = fNamespaceContext.getURI(prefix); sendElementEvent("prefix", prefix); sendElementEvent("namespaceName", uri); sendUnIndentedElement("namespace"); } sendUnIndentedElement("inScopeNamespaces"); } //printinScopeNamespaces() /* The following information will be available at the startElement call: * name, namespace, type, notation, validation context * * The following information will be available at the endElement call: * nil, specified, normalized value, member type, validity, error codes, * default */ private void processPSVIStartElement(Augmentations augs) { if (augs == null) return; ElementPSVI elemPSVI = (ElementPSVI)augs.getItem(Constants.ELEMENT_PSVI); if (elemPSVI != null) { // Should we store the values till end element call? -- AY // I don't think so -- PJM } } /* The following information will be available at the startElement call: * name, namespace, type, notation, validation context * * The following information will be available at the endElement call: * nil, specified, normalized value, member type, validity, error codes, * default */ private void processPSVIEndElement(Augmentations augs) { if (augs == null) return; ElementPSVI elemPSVI = (ElementPSVI)augs.getItem(Constants.ELEMENT_PSVI); if (elemPSVI != null) { processPSVISchemaInformation(elemPSVI); sendElementEvent( "psv:validationAttempted", this.translateValidationAttempted( elemPSVI.getValidationAttempted())); // Would rather getValidationContext() return element info item. // This is non the same as XSV. sendElementEvent( "psv:validationContext", elemPSVI.getValidationContext()); sendElementEvent( "psv:validity", this.translateValidity(elemPSVI.getValidity())); processPSVISchemaErrorCode(elemPSVI.getErrorCodes()); sendElementEvent( "psv:schemaNormalizedValue", getSchemaNormalizedValue(elemPSVI)); sendElementEvent( "psv:schemaSpecified", elemPSVI.getIsSchemaSpecified() ? "schema" : "infoset"); sendElementEvent("psv:schemaDefault", elemPSVI.getSchemaDefault()); processPSVITypeDefinitionRef( "psv:typeDefinition", elemPSVI.getTypeDefinition()); processPSVITypeDefinitionRef( "psv:memberTypeDefinition", elemPSVI.getMemberTypeDefinition()); // A value for nil is not necessary, since we output declaration, instead. // See http://www.w3.org/TR/xmlschema-1/#section-Element-Declaration-Information-Set-Contributions. sendElementEvent("psv:nil"); sendIndentedElement("psv:declaration"); processPSVIElementRef( "psv:elementDeclaration", elemPSVI.getElementDeclaration()); sendUnIndentedElement("psv:declaration"); processPSVIElementRef("psv:notation", elemPSVI.getNotation()); // idref table does not have to be exposed, and is not exposed sendElementEvent("psv:idIdrefTable"); // identity constraint table does not have to be exposed, and is not exposed sendElementEvent("psv:identityConstraintTable"); } } private void processPSVIAttribute(Augmentations augs) { if (augs == null) return; AttributePSVI attrPSVI = (AttributePSVI)augs.getItem(Constants.ATTRIBUTE_PSVI); if (attrPSVI != null) { sendElementEvent( "psv:validationAttempted", this.translateValidationAttempted( attrPSVI.getValidationAttempted())); // Would rather getValidationContext() return element info item. // This is not the same as XSV. sendElementEvent( "psv:validationContext", attrPSVI.getValidationContext()); sendElementEvent( "psv:validity", this.translateValidity(attrPSVI.getValidity())); processPSVISchemaErrorCode(attrPSVI.getErrorCodes()); sendElementEvent( "psv:schemaNormalizedValue", getSchemaNormalizedValue(attrPSVI)); sendElementEvent( "psv:schemaSpecified", attrPSVI.getIsSchemaSpecified() ? "schema" : "infoset"); sendElementEvent("psv:schemaDefault", attrPSVI.getSchemaDefault()); processPSVITypeDefinitionRef( "psv:typeDefinition", attrPSVI.getTypeDefinition()); processPSVITypeDefinitionRef( "psv:memberTypeDefinition", attrPSVI.getMemberTypeDefinition()); if (attrPSVI.getAttributeDeclaration() == null) { sendElementEvent("psv:declaration"); } else { sendIndentedElement("psv:declaration"); processPSVIAttributeDeclarationRef( attrPSVI.getAttributeDeclaration()); sendUnIndentedElement("psv:declaration"); } } } private void processPSVISchemaErrorCode(StringList errorCodes) { StringBuffer errorBuffer = new StringBuffer(); if (errorCodes != null && errorCodes.getLength() > 0) { for (int i = 0; i < errorCodes.getLength() - 1; i++) { errorBuffer.append(errorCodes.item(i)); errorBuffer.append(" "); } errorBuffer.append(errorCodes.item(errorCodes.getLength() - 1)); } sendElementEvent("psv:schemaErrorCode", errorBuffer.toString()); } private void processPSVISchemaInformation(ElementPSVI elemPSVI) { if (elemPSVI == null) return; XSModel schemaInfo = elemPSVI.getSchemaInformation(); XSNamespaceItemList schemaNamespaces = schemaInfo == null ? null : schemaInfo.getNamespaceItems(); if (schemaNamespaces == null || schemaNamespaces.getLength() == 0) { sendElementEvent("psv:schemaInformation"); } else { sendIndentedElement("psv:schemaInformation"); for (int i = 0; i < schemaNamespaces.getLength(); i++) { processPSVINamespaceItem(schemaNamespaces.item(i)); } sendUnIndentedElement("psv:schemaInformation"); } } private void processPSVINamespaceItem(XSNamespaceItem item) { if (item == null) return; String namespace = item.getSchemaNamespace(); if (namespace != null && namespace.equals(Constants.NS_XMLSCHEMA)) { // we don't want to output information for schema for schemas return; } sendIndentedElement("psv:namespaceSchemaInformation"); sendElementEvent("psv:schemaNamespace", namespace); // print out schema components processPSVISchemaComponents(item); // print out schema document information processPSVISchemaDocuments(item); // print out schema annotations processPSVISchemaAnnotations(item.getAnnotations()); sendUnIndentedElement("psv:namespaceSchemaInformation"); } private void processPSVISchemaDocuments(XSNamespaceItem item) { StringList locations = item == null ? null : item.getDocumentLocations(); if (locations == null || locations.getLength() == 0) { sendEmptyElementEvent("psv:schemaDocuments"); return; } sendIndentedElement("psv:schemaDocuments"); for (int i = 0; i < locations.getLength(); i++) { sendIndentedElement("psv:schemaDocument"); sendElementEvent("psv:documentLocation", locations.item(i)); // It's supposed to point to a element, and we're not really // dealing with those (except for the one at the root) sendElementEvent("psv:document"); sendUnIndentedElement("psv:schemaDocument"); } sendUnIndentedElement("psv:schemaDocuments"); } private void processPSVISchemaComponents(XSNamespaceItem item) { if (item == null) { sendEmptyElementEvent("psv:schemaComponents"); return; } // it we happen to not get any components, this will output a start tag // and a close tag, instead of an empty element tag. This isn't a big // deal, though sendIndentedElement("psv:schemaComponents"); // typeDefinitions XSNamedMap components = item.getComponents(XSConstants.TYPE_DEFINITION); for (int i = 0; i < components.getLength(); i++) { processPSVITypeDefinition((XSTypeDefinition)components.item(i)); } // elementDeclarations components = item.getComponents(XSConstants.ELEMENT_DECLARATION); for (int i = 0; i < components.getLength(); i++) { processPSVIElementDeclaration( (XSElementDeclaration)components.item(i)); } // attributeDeclarations components = item.getComponents(XSConstants.ATTRIBUTE_DECLARATION); for (int i = 0; i < components.getLength(); i++) { processPSVIAttributeDeclaration( (XSAttributeDeclaration)components.item(i)); } // modelGroupDefinitions components = item.getComponents(XSConstants.MODEL_GROUP_DEFINITION); for (int i = 0; i < components.getLength(); i++) { processPSVIModelGroupDefinition( (XSModelGroupDefinition)components.item(i)); } // attributeGroupDefinitions components = item.getComponents(XSConstants.ATTRIBUTE_GROUP); for (int i = 0; i < components.getLength(); i++) { processPSVIAttributeGroupDefinition( (XSAttributeGroupDefinition)components.item(i)); } // notationDeclarations components = item.getComponents(XSConstants.NOTATION_DECLARATION); for (int i = 0; i < components.getLength(); i++) { processPSVINotationDeclaration( (XSNotationDeclaration)components.item(i)); } sendUnIndentedElement("psv:schemaComponents"); } private void processPSVITypeDefinition(XSTypeDefinition type) { if (type == null) return; if (type.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { processPSVIComplexTypeDefinition((XSComplexTypeDefinition)type); } else if (type.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) { processPSVISimpleTypeDefinition((XSSimpleTypeDefinition)type); } else { throw new IllegalArgumentException( "Unknown type definition value: " + type.getType()); } } private void processPSVIComplexTypeDefinition(XSComplexTypeDefinition type) { if (type == null) return; sendIndentedElementWithID("psv:complexTypeDefinition", type); sendElementEvent("psv:name", type.getName()); sendElementEvent("psv:targetNamespace", type.getNamespace()); processPSVITypeDefinitionOrRef( "psv:baseTypeDefinition", type.getBaseType()); sendElementEvent( "psv:derivationMethod", this.translateDerivation(type.getDerivationMethod())); sendElementEvent("psv:final", this.translateBlockOrFinal(type.getFinal())); sendElementEvent("psv:abstract", String.valueOf(type.getAbstract())); processPSVIAttributeUses(type.getAttributeUses()); processPSVIAttributeWildcard(type.getAttributeWildcard()); sendIndentedElement("psv:contentType"); sendElementEvent( "psv:variety", this.translateContentType(type.getContentType())); XSSimpleTypeDefinition simpleType = type.getSimpleType(); if(simpleType == null || (!simpleType.getAnonymous() || fDefined.contains(this.getID(simpleType)))) { processPSVIElementRef("psv:simpleTypeDefinition", simpleType); } else { processPSVISimpleTypeDefinition(simpleType); } processPSVIParticle(type.getParticle()); sendUnIndentedElement("psv:contentType"); sendElementEvent( "psv:prohibitedSubstitutions", this.translateBlockOrFinal(type.getProhibitedSubstitutions())); processPSVIAnnotations(type.getAnnotations()); sendUnIndentedElement("psv:complexTypeDefinition"); } private void processPSVISimpleTypeDefinition(XSSimpleTypeDefinition type) { if (type == null) { sendElementEvent("psv:simpleTypeDefinition"); return; } sendIndentedElementWithID("psv:simpleTypeDefinition", type); sendElementEvent("psv:name", type.getName()); sendElementEvent("psv:targetNamespace", type.getNamespace()); processPSVITypeDefinitionOrRef( "psv:baseTypeDefinition", type.getBaseType()); processPSVITypeDefinitionOrRef( "psv:primitiveTypeDefinition", type.getPrimitiveType()); processPSVIFacets(type); sendIndentedElement("psv:fundamentalFacets"); sendIndentedElement("psv:ordered"); sendElementEvent("psv:value", this.translateOrdered(type.getOrdered())); sendUnIndentedElement("psv:ordered"); sendIndentedElement("psv:bounded"); sendElementEvent("psv:value", String.valueOf(type.getBounded())); sendUnIndentedElement("psv:bounded"); sendIndentedElement("psv:cardinality"); sendElementEvent("psv:value", String.valueOf(type.getFinite())); sendUnIndentedElement("psv:cardinality"); sendIndentedElement("psv:numeric"); sendElementEvent("psv:value", String.valueOf(type.getNumeric())); sendUnIndentedElement("psv:numeric"); sendUnIndentedElement("psv:fundamentalFacets"); sendElementEvent("psv:final", this.translateBlockOrFinal(type.getFinal())); sendElementEvent( "psv:variety", this.translateVariety(type.getVariety())); processPSVITypeDefinitionOrRef( "psv:itemTypeDefinition", type.getItemType()); processPSVIMemberTypeDefinitions(type.getMemberTypes()); processPSVIAnnotations(type.getAnnotations()); sendUnIndentedElement("psv:simpleTypeDefinition"); } private void processPSVIFacets(XSSimpleTypeDefinition type) { if (type == null) return; XSObjectList facets = type.getFacets(); XSObjectList multiValueFacets = type.getMultiValueFacets(); if ((facets == null || facets.getLength() == 0) && (multiValueFacets == null || multiValueFacets.getLength() == 0)) { sendElementEvent("psv:facets"); } else { sendIndentedElement("psv:facets"); if (facets != null) { for (int i = 0; i < facets.getLength(); i++) { XSFacet facet = (XSFacet)facets.item(i); String name = this.translateFacetKind(facet.getFacetKind()); sendIndentedElement("psv:" + name); sendElementEvent("psv:value", facet.getLexicalFacetValue()); sendElementEvent( "psv:fixed", String.valueOf(facet.getFixed())); processPSVIAnnotation(facet.getAnnotation()); sendUnIndentedElement("psv:" + name); } } if (multiValueFacets != null) { for (int i = 0; i < multiValueFacets.getLength(); i++) { XSMultiValueFacet facet = (XSMultiValueFacet)multiValueFacets.item(i); String name = this.translateFacetKind(facet.getFacetKind()); sendIndentedElement("psv:" + name); StringList values = facet.getLexicalFacetValues(); for (int j = 0; j < values.getLength(); j++) { sendElementEvent("psv:value", values.item(j)); } sendElementEvent("psv:fixed", "false"); processPSVIAnnotations(facet.getAnnotations()); sendUnIndentedElement("psv:" + name); } } sendUnIndentedElement("psv:facets"); } } private void processPSVIMemberTypeDefinitions(XSObjectList memTypes) { if (memTypes == null || memTypes.getLength() == 0) { sendElementEvent("psv:memberTypeDefinitions"); } else { sendIndentedElement("psv:memberTypeDefinitions"); for (int i = 0; i < memTypes.getLength(); i++) { processPSVITypeDefinitionOrRef( "psv:memberTypeDefinition", (XSTypeDefinition)memTypes.item(i)); } sendUnIndentedElement("psv:memberTypeDefinitions"); } } /* It's possible that this method will send events for null annotations, i.e. * * * ... * * * This is because of the way multi-value facet is implemented. It represents * the annotation on each value of the facet, and if a value doesn't have one, * it's corresponding annotation is null. Thus, it's possible for the first * annotation to be null, but the second one to be exist. * * An exception to this is if all of the annotations are null; then I output * */ private void processPSVIAnnotations(XSObjectList annotations) { boolean empty = true; if (annotations != null && annotations.getLength() > 0) { for (int i = 0; i < annotations.getLength(); i++) { if (annotations.item(i) != null) { empty = false; break; } } } if (empty) { sendElementEvent("psv:annotations"); } else { sendIndentedElement("psv:annotations"); for (int i = 0; i < annotations.getLength(); i++) { processPSVIAnnotation((XSAnnotation)annotations.item(i)); } sendUnIndentedElement("psv:annotations"); } } private void processPSVISchemaAnnotations(XSObjectList annotations) { if (annotations == null || annotations.getLength() == 0) { sendElementEvent("psv:schemaAnnotations"); } else { sendIndentedElement("psv:schemaAnnotations"); for (int i = 0; i < annotations.getLength(); i++) { processPSVIAnnotation((XSAnnotation)annotations.item(i)); } sendUnIndentedElement("psv:schemaAnnotations"); } } private void processPSVIAttributeUses(XSObjectList uses) { if (uses == null || uses.getLength() == 0) { sendElementEvent("psv:attributeUses"); } else { sendIndentedElement("psv:attributeUses"); for (int i = 0; i < uses.getLength(); i++) { XSAttributeUse use = (XSAttributeUse)uses.item(i); sendIndentedElement("psv:attributeUse"); sendElementEvent("psv:required", String.valueOf(use.getRequired())); processPSVIAttributeDeclarationOrRef(use.getAttrDeclaration()); processPSVIValueConstraint(use.getConstraintType(), getConstraintValue(use)); sendUnIndentedElement("psv:attributeUse"); } sendUnIndentedElement("psv:attributeUses"); } } private void processPSVIAttributeWildcard(XSWildcard wildcard) { if (wildcard == null) { sendElementEvent("psv:attributeWildcard"); } else { sendIndentedElement("psv:attributeWildcard"); processPSVIWildcard(wildcard); sendUnIndentedElement("psv:attributeWildcard"); } } private void processPSVIWildcard(XSWildcard wildcard) { if (wildcard == null) return; sendIndentedElement("psv:wildcard"); sendIndentedElement("psv:namespaceConstraint"); sendElementEvent( "psv:variety", this.translateConstraintType(wildcard.getConstraintType())); StringBuffer constraintBuffer = new StringBuffer(); StringList constraints = wildcard.getNsConstraintList(); if (constraints != null && constraints.getLength() > 0) { for (int i = 0; i < constraints.getLength() - 1; i++) { constraintBuffer.append(constraints.item(i)); constraintBuffer.append(" "); } constraintBuffer.append( constraints.item(constraints.getLength() - 1)); } sendElementEvent("psv:namespaces", constraintBuffer.toString()); sendUnIndentedElement("psv:namespaceConstraint"); sendElementEvent( "psv:processContents", this.translateProcessContents(wildcard.getProcessContents())); processPSVIAnnotation(wildcard.getAnnotation()); sendUnIndentedElement("psv:wildcard"); } private void processPSVIAnnotation(XSAnnotation ann) { if (ann == null) { sendElementEvent("psv:annotation"); } else { sendIndentedElement("psv:annotation"); // We can't get all the information from DOM, but I've outputed what // we can get -- PJM Node dom = new DocumentImpl(); ann.writeAnnotation(dom, XSAnnotation.W3C_DOM_DOCUMENT); // this child will be the annotation element Element annot = DOMUtil.getFirstChildElement(dom); processDOMElement( annot, SchemaSymbols.ELT_APPINFO, "psv:applicationInformation"); processDOMElement( annot, SchemaSymbols.ELT_DOCUMENTATION, "psv:userInformation"); processDOMAttributes(annot); sendUnIndentedElement("psv:annotation"); } } private void processDOMElement( Node node, String elementName, String tagName) { if (node == null) return; boolean foundElem = false; for (Element child = DOMUtil.getFirstChildElement(node); child != null; child = DOMUtil.getNextSiblingElement(child)) { if (DOMUtil.getLocalName(child).equals(elementName)) { if (!foundElem) { sendIndentedElement(tagName); foundElem = true; } sendIndentedElement("element"); sendElementEvent( "namespaceName", DOMUtil.getNamespaceURI(child)); sendElementEvent("localName", DOMUtil.getLocalName(child)); sendElementEvent("prefix", child.getPrefix()); sendIndentedElement("children"); sendIndentedElement("character"); sendElementEvent("textContent", DOMUtil.getChildText(child)); sendUnIndentedElement("character"); sendUnIndentedElement("children"); //Create XMLAttributes from DOM Attr[] atts = (Element) child == null ? null : DOMUtil.getAttrs((Element) child); XMLAttributes attrs = new XMLAttributesImpl(); for (int i=0; i fIndentChars.length) { fIndentChars = new char[fIndentChars.length * 2]; for (int i = 0; i < fIndentChars.length; i++) { fIndentChars[i] = '\t'; } } XMLString text = new XMLString(fIndentChars, 0, fIndent); fDocumentHandler.characters(text, null); } private void sendNewLine() { fDocumentHandler.characters(newLine, null); } private QName createQName(String rawname) { int index = rawname.indexOf(':'); String prefix, localpart; if (index == -1) { prefix = ""; localpart = rawname; } else { prefix = rawname.substring(0, index); localpart = rawname.substring(index + 1); } String uri = fPSVINamespaceContext.getURI(prefix); return new QName(prefix, localpart, rawname, uri); } private XMLAttributes createAttributes(List atts) { XMLAttributes attributes = new XMLAttributesImpl(); if (atts != null) { for (int i = 0; i < atts.size(); i += 3) { String rawname = (String)atts.get(i); String value = (String)atts.get(i + 1); String type = (String)atts.get(i + 2); attributes.addAttribute(createQName(rawname), type, value); } } return attributes; } private String createID(XSObject obj) { String namespace = obj.getNamespace(); String prefix = fNamespaceContext.getPrefix(obj.getNamespace()); String name = obj.getName(); String type = this.translateType(obj.getType()); // must be anonymous if (name == null) { name = "anon_" + fAnonNum++; } // no namespace else if (namespace == null || namespace == XMLSymbols.EMPTY_STRING) { name = name + "." + fAnonNum++; } if (namespace == Constants.NS_XMLSCHEMA) { return name; } else { return (prefix == null ? "" : prefix + ".") + type + "." + name; } } private String getID(XSObject obj) { if (obj == null) return null; String id = (String)fIDMap.get(obj); if (id == null) { id = createID(obj); fIDMap.put(obj, id); } return id; } private String translateType(short type) { switch (type) { case XSConstants.TYPE_DEFINITION : return "type"; case XSConstants.ANNOTATION : return "annot"; case XSConstants.ATTRIBUTE_DECLARATION : return "attr"; case XSConstants.ATTRIBUTE_GROUP : return "ag"; case XSConstants.ATTRIBUTE_USE : return "au"; case XSConstants.ELEMENT_DECLARATION : return "elt"; case XSConstants.MODEL_GROUP_DEFINITION : return "mg"; case XSConstants.NOTATION_DECLARATION : return "not"; case XSConstants.IDENTITY_CONSTRAINT : return "idc"; default : return "unknown"; } } private String translateFacetKind(short kind) { switch (kind) { case XSSimpleTypeDefinition.FACET_WHITESPACE : return SchemaSymbols.ELT_WHITESPACE; case XSSimpleTypeDefinition.FACET_LENGTH : return SchemaSymbols.ELT_LENGTH; case XSSimpleTypeDefinition.FACET_MINLENGTH : return SchemaSymbols.ELT_MINLENGTH; case XSSimpleTypeDefinition.FACET_MAXLENGTH : return SchemaSymbols.ELT_MAXLENGTH; case XSSimpleTypeDefinition.FACET_TOTALDIGITS : return SchemaSymbols.ELT_TOTALDIGITS; case XSSimpleTypeDefinition.FACET_FRACTIONDIGITS : return SchemaSymbols.ELT_FRACTIONDIGITS; case XSSimpleTypeDefinition.FACET_PATTERN : return SchemaSymbols.ELT_PATTERN; case XSSimpleTypeDefinition.FACET_ENUMERATION : return SchemaSymbols.ELT_ENUMERATION; case XSSimpleTypeDefinition.FACET_MAXINCLUSIVE : return SchemaSymbols.ELT_MAXINCLUSIVE; case XSSimpleTypeDefinition.FACET_MAXEXCLUSIVE : return SchemaSymbols.ELT_MAXEXCLUSIVE; case XSSimpleTypeDefinition.FACET_MINEXCLUSIVE : return SchemaSymbols.ELT_MINEXCLUSIVE; case XSSimpleTypeDefinition.FACET_MININCLUSIVE : return SchemaSymbols.ELT_MININCLUSIVE; default : return "unknown"; } } private String translateVariety(short var) { switch (var) { case XSSimpleTypeDefinition.VARIETY_LIST : return "list"; case XSSimpleTypeDefinition.VARIETY_UNION : return "union"; case XSSimpleTypeDefinition.VARIETY_ATOMIC : return "atomic"; case XSSimpleTypeDefinition.VARIETY_ABSENT : return null; default : return "unknown"; } } private String translateConstraintType(short type) { switch (type) { case XSWildcard.NSCONSTRAINT_ANY : return "any"; // the spec says that when it's a list, the "type" shouldn't be there case XSWildcard.NSCONSTRAINT_LIST : return null; case XSWildcard.NSCONSTRAINT_NOT : return "not"; default : return "unknown"; } } private String translateValueConstraintType(short type) { switch (type) { case XSConstants.VC_DEFAULT : return "default"; case XSConstants.VC_FIXED : return "fixed"; default : return "unknown"; } } private String translateBlockOrFinal(short val) { String ret = ""; if ((val & XSConstants.DERIVATION_EXTENSION) != 0) { ret += SchemaSymbols.ATTVAL_EXTENSION; } if ((val & XSConstants.DERIVATION_LIST) != 0) { if (ret.length() != 0) ret += " "; ret += SchemaSymbols.ATTVAL_LIST; } if ((val & XSConstants.DERIVATION_RESTRICTION) != 0) { if (ret.length() != 0) ret += " "; ret += SchemaSymbols.ATTVAL_RESTRICTION; } if ((val & XSConstants.DERIVATION_UNION) != 0) { if (ret.length() != 0) ret += " "; ret += SchemaSymbols.ATTVAL_UNION; } if ((val & XSConstants.DERIVATION_SUBSTITUTION) != 0) { if (ret.length() != 0) ret += " "; ret += SchemaSymbols.ATTVAL_SUBSTITUTION; } return ret; } private String translateScope(short scope) { switch (scope) { case XSConstants.SCOPE_ABSENT : return null; case XSConstants.SCOPE_GLOBAL : return "global"; case XSConstants.SCOPE_LOCAL : return "local"; default : return "unknown"; } } private String translateCompositor(short comp) { switch (comp) { case XSModelGroup.COMPOSITOR_SEQUENCE : return SchemaSymbols.ELT_SEQUENCE; case XSModelGroup.COMPOSITOR_CHOICE : return SchemaSymbols.ELT_CHOICE; case XSModelGroup.COMPOSITOR_ALL : return SchemaSymbols.ELT_ALL; default : return "unknown"; } } private String translateContentType(short contentType) { switch (contentType) { case XSComplexTypeDefinition.CONTENTTYPE_ELEMENT : return "elementOnly"; case XSComplexTypeDefinition.CONTENTTYPE_EMPTY : return "empty"; case XSComplexTypeDefinition.CONTENTTYPE_MIXED : return "mixed"; case XSComplexTypeDefinition.CONTENTTYPE_SIMPLE : return "simple"; default : return "unknown"; } } private String translateProcessContents(short process) { switch (process) { case XSWildcard.PC_LAX : return SchemaSymbols.ATTVAL_LAX; case XSWildcard.PC_SKIP : return SchemaSymbols.ATTVAL_SKIP; case XSWildcard.PC_STRICT : return SchemaSymbols.ATTVAL_STRICT; default : return "unknown"; } } private String translateDerivation(short deriv) { switch (deriv) { case XSConstants.DERIVATION_EXTENSION : return SchemaSymbols.ELT_EXTENSION; case XSConstants.DERIVATION_LIST : return SchemaSymbols.ELT_LIST; case XSConstants.DERIVATION_RESTRICTION : return SchemaSymbols.ELT_RESTRICTION; case XSConstants.DERIVATION_SUBSTITUTION : return SchemaSymbols.ATTVAL_SUBSTITUTION; case XSConstants.DERIVATION_UNION : return SchemaSymbols.ELT_UNION; case XSConstants.DERIVATION_NONE : return null; default : return "unknown"; } } private String translateCategory(short cat) { switch (cat) { case XSIDCDefinition.IC_KEY : return SchemaSymbols.ELT_KEY; case XSIDCDefinition.IC_KEYREF : return SchemaSymbols.ELT_KEYREF; case XSIDCDefinition.IC_UNIQUE : return SchemaSymbols.ELT_UNIQUE; default : return "unknown"; } } private String translateOrdered(short ordered) { switch (ordered) { case XSSimpleTypeDefinition.ORDERED_FALSE : return "false"; case XSSimpleTypeDefinition.ORDERED_PARTIAL : return "partial"; case XSSimpleTypeDefinition.ORDERED_TOTAL : return "total"; default : return "unknown"; } } private String translateValidationAttempted(short val) { switch (val) { case ItemPSVI.VALIDATION_NONE : return "none"; case ItemPSVI.VALIDATION_PARTIAL : return "partial"; case ItemPSVI.VALIDATION_FULL : return "full"; default : return "unknown"; } } private String translateValidity(short val) { switch (val) { case ItemPSVI.VALIDITY_NOTKNOWN : return "notKnown"; case ItemPSVI.VALIDITY_VALID : return "valid"; case ItemPSVI.VALIDITY_INVALID : return "invalid"; default : return "unknown"; } } /** * Check whether the calling event is first in children list , * if yes print the . */ private void checkForChildren() { if (!_elementState.empty()) { ElementState fElementState = (ElementState)_elementState.peek(); if (fElementState.isEmpty == true) { sendIndentedElement("children"); fElementState.isEmpty = false; } } else { sendIndentedElement("children"); _elementState.push(new ElementState(false)); } } //checkForChildren private String getConstraintValue(XSElementDeclaration elemDecl) { return getConstraintValue(elemDecl.getValueConstraintValue()); } // getConstraintValue(XSElementDeclaration) private String getConstraintValue(XSAttributeDeclaration attrDecl) { return getConstraintValue(attrDecl.getValueConstraintValue()); } // getConstraintValue(XSAttributeDeclaration) private String getConstraintValue(XSAttributeUse attrUse) { return getConstraintValue(attrUse.getValueConstraintValue()); } // getConstraintValue(XSAttributeUse) private String getConstraintValue(XSValue vcValue) { return (vcValue != null) ? vcValue.getNormalizedValue() : null; } // getConstraintValue(XSValue) private String getSchemaNormalizedValue(ItemPSVI itemPSVI) { XSValue schemaValue = itemPSVI.getSchemaValue(); return (schemaValue != null) ? schemaValue.getNormalizedValue() : null; } // getSchemaNormalizedValue(ItemPSVI) static final class ElementState { public boolean isEmpty; XMLAttributes fAttributes; public ElementState(XMLAttributes attributes) { fAttributes = attributes; isEmpty = true; } public ElementState(boolean value) { isEmpty = value; } public XMLAttributes getAttributes() { return fAttributes; } public void isEmpty(boolean value) { isEmpty = value; } } //class ElementState } // class PSVIWriter