xerces-2_12_1-xml-schema-1.1.samples.xni.PSVIWriter Maven / Gradle / Ivy
Show all versions of ibis-xerces Show documentation
/*
* 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: PSVIWriter.java 1062647 2011-01-24 04:45:26Z mrglavas $
*/
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
* 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