You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by mu...@apache.org on 2011/07/23 04:13:23 UTC
svn commit: r1149782 -
/xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java
Author: mukulg
Date: Sat Jul 23 02:13:22 2011
New Revision: 1149782
URL: http://svn.apache.org/viewvc?rev=1149782&view=rev
Log:
making few improvements to XSSerializer (particularly removing unnecessary whitespaces and using constants from SchemaSymbols instead of writing them as literals again).
Added:
xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java
Added: xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java
URL: http://svn.apache.org/viewvc/xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java?rev=1149782&view=auto
==============================================================================
--- xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java (added)
+++ xerces/java/branches/xml-schema-1.1-dev/samples/xs/XSSerializer.java Sat Jul 23 02:13:22 2011
@@ -0,0 +1,1169 @@
+/*
+ * 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 xs;
+
+import java.io.StringReader;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.xerces.impl.Constants;
+import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl;
+import org.apache.xerces.impl.xs.SchemaSymbols;
+import org.apache.xerces.impl.xs.XMLSchemaLoader;
+import org.apache.xerces.impl.xs.XSAnnotationImpl;
+import org.apache.xerces.impl.xs.XSAttributeDecl;
+import org.apache.xerces.impl.xs.XSAttributeGroupDecl;
+import org.apache.xerces.impl.xs.XSComplexTypeDecl;
+import org.apache.xerces.impl.xs.XSElementDecl;
+import org.apache.xerces.impl.xs.XSGroupDecl;
+import org.apache.xerces.impl.xs.XSModelGroupImpl;
+import org.apache.xerces.impl.xs.XSWildcardDecl;
+import org.apache.xerces.impl.xs.identity.Field;
+import org.apache.xerces.impl.xs.identity.IdentityConstraint;
+import org.apache.xerces.impl.xs.identity.KeyRef;
+import org.apache.xerces.impl.xs.identity.Selector;
+import org.apache.xerces.impl.xs.util.XSTypeHelper;
+import org.apache.xerces.xs.StringList;
+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.XSMultiValueFacet;
+import org.apache.xerces.xs.XSNamedMap;
+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.XSTerm;
+import org.apache.xerces.xs.XSTypeDefinition;
+import org.apache.xerces.xs.XSValue;
+import org.apache.xerces.xs.XSWildcard;
+import org.w3c.dom.DOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.bootstrap.DOMImplementationRegistry;
+import org.w3c.dom.ls.DOMImplementationLS;
+import org.w3c.dom.ls.LSOutput;
+import org.w3c.dom.ls.LSSerializer;
+import org.xml.sax.InputSource;
+
+/**
+ * XSModel serialization utility.
+ * This utility serializes the Xerces XSModel into lexical, XSD syntax.
+ *
+ * @author Mukul Gandhi, IBM
+ * @version $Id$
+ */
+public class XSSerializer {
+
+ private static final String XSD_LANGUAGE_URI = SchemaSymbols.URI_SCHEMAFORSCHEMA;
+ private static final String XML_SCHEMA_VERSION = Constants.XERCES_PROPERTY_PREFIX + Constants.XML_SCHEMA_VERSION_PROPERTY;
+ private static String XSD_LANGUAGE_PREFIX = "xs:";
+
+
+ /*
+ * "Main method"
+ *
+ * An entry point to test this utility.
+ *
+ * The XSModel could be synthesized by any means (for example, by direct
+ * API calls to Xerces Schema API, methods) -- in which case, the method
+ * "serialize" will be used directly, passing in the XSModel object.
+ */
+ public static void main(String[] args) {
+
+ if (args.length == 0 || args.length > 5) {
+ printUsage();
+ System.exit(-1);
+ }
+
+ // the last command line argument must be a schema URI
+ String schemaUri = args[args.length - 1];
+
+ // iterate other command line arguments
+ String schemaVersion = null;
+ String schemaPrefix = null;
+ for (int argIndx = 0; argIndx < args.length - 1; argIndx += 2) {
+ if (args[argIndx].equals("-version")) {
+ schemaVersion = args[argIndx + 1];
+ }
+ else if (args[argIndx].equals("-prefix")) {
+ if (argIndx + 1 < args.length - 1) {
+ schemaPrefix = args[argIndx + 1];
+ }
+ }
+ }
+
+ XMLSchemaLoader xsLoader = new XMLSchemaLoader();
+ if ("1.1".equals(schemaVersion)) {
+ xsLoader.setProperty(XML_SCHEMA_VERSION, Constants.W3C_XML_SCHEMA11_NS_URI);
+ }
+ else if (schemaVersion != null && !"1.0".equals(schemaVersion)) {
+ printUsage();
+ System.exit(-1);
+ }
+
+ if (schemaPrefix != null) {
+ XSD_LANGUAGE_PREFIX = schemaPrefix + ":";
+ }
+
+ // construct the XSModel object from a schema document
+ XSModel xsModel = xsLoader.loadURI(schemaUri);
+
+ try {
+ // instantiate the serializer and invoke serialization method
+ XSSerializer xsSerializer = new XSSerializer();
+ xsSerializer.serialize(xsModel);
+ }
+ catch(Exception ex) {
+ ex.printStackTrace();
+ }
+
+ } // main
+
+
+ /*
+ * Print a diagnostic message, explaining how to invoke this sample.
+ */
+ private static void printUsage() {
+
+ System.err.println("Usage:");
+ System.err.println("java xs.XSSerializer [options] schema.xsd");
+ System.err.println("\nOptions:");
+ System.err.println("-version [1.0|1.1] XSD language level (default level is 1.0)");
+ System.err.println("-prefix <prefix> XSD language URI prefix (for e.g 'xs' or 'xsd'), for the serialized output");
+
+ } // printUsage
+
+
+ /*
+ * Serialize an XML Schema, XSModel object to the standard output.
+ */
+ public void serialize(XSModel xsModel) throws Exception {
+
+ //get DOM after conversion, from XSModel
+ Document xsdDocument = transformXSModelToDOMTree(xsModel);
+
+ // serialize the DOM to XML Schema document
+ DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
+ DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS");
+ LSSerializer writer = impl.createLSSerializer();
+ writer.getDomConfig().setParameter("format-pretty-print", Boolean.TRUE);
+ LSOutput output = impl.createLSOutput();
+ output.setEncoding("UTF-8");
+ output.setByteStream(System.out);
+ writer.write(xsdDocument, output);
+
+ } // serialize
+
+
+ /*
+ * Transform an XML Schema, XSModel object into DOM document.
+ */
+ public Document transformXSModelToDOMTree(XSModel xsModel) throws Exception {
+
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ DocumentBuilder dBuilder = dbf.newDocumentBuilder();
+ Document document = dBuilder.newDocument();
+
+ Element schemaDeclDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_SCHEMA);
+
+ document.appendChild(schemaDeclDomNode);
+
+ // process global element declarations
+ XSNamedMap globalElemDecls = xsModel.getComponents(XSConstants.ELEMENT_DECLARATION);
+ processGlobalElementDecl(globalElemDecls, document, schemaDeclDomNode);
+
+ // process global complex type declarations
+ XSNamedMap globalComplexTypeDecls = xsModel.getComponents(XSTypeDefinition.COMPLEX_TYPE);
+ processGlobalComplexTypeDecl(globalComplexTypeDecls, document, schemaDeclDomNode);
+
+ // process global simple type declarations
+ XSNamedMap globalSimpleTypeDecls = xsModel.getComponents(XSTypeDefinition.SIMPLE_TYPE);
+ processGlobalSimpleTypeDecl(globalSimpleTypeDecls, document, schemaDeclDomNode);
+
+ // process global attribute declarations
+ XSNamedMap globalAttrDecls = xsModel.getComponents(XSConstants.ATTRIBUTE_DECLARATION);
+ processGlobalAttrDecl(globalAttrDecls, document, schemaDeclDomNode);
+
+ // process global attribute group declarations
+ XSNamedMap globalAttrGroupDecls = xsModel.getComponents(XSConstants.ATTRIBUTE_GROUP);
+ processGlobalAttrGroupDecl(globalAttrGroupDecls, document, schemaDeclDomNode);
+
+ // process global model group declarations
+ XSNamedMap globalGroupDecls = xsModel.getComponents(XSConstants.MODEL_GROUP_DEFINITION);
+ processGlobalGroupDecl(globalGroupDecls, document, schemaDeclDomNode);
+
+ return document;
+
+ } // transformXSModelToDOMTree
+
+
+ /*
+ * Process global attribute group declarations.
+ */
+ private void processGlobalAttrGroupDecl(XSNamedMap globalAttrGpDecls, Document document, Element schemaDeclDomNode) {
+
+ // iterating global attribute group declarations in the Schema
+ for (int attrGpIdx = 0; attrGpIdx < globalAttrGpDecls.size(); attrGpIdx++) {
+ XSAttributeGroupDecl attrGpDecl = (XSAttributeGroupDecl) globalAttrGpDecls.item(attrGpIdx);
+ String attrGpName = attrGpDecl.getName();
+ Element attrGpDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_ATTRIBUTEGROUP);
+ attrGpDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, attrGpName);
+
+ // add annotation to attribute group
+ XSAnnotationImpl attrGpAnnotation = (XSAnnotationImpl) attrGpDecl.getAnnotation();
+ if (attrGpAnnotation != null) {
+ addAnnotationToSchemaComponent(document, attrGpDomNode, attrGpAnnotation);
+ }
+
+ XSObjectList attrUses = attrGpDecl.getAttributeUses();
+ for (int attrUsesIdx = 0; attrUsesIdx < attrUses.size(); attrUsesIdx++) {
+ XSAttributeUse attrUse = (XSAttributeUse) attrUses.item(attrUsesIdx);
+ XSAttributeDecl attrDecl = (XSAttributeDecl) attrUse.getAttrDeclaration();
+ String constraintName = null;
+ String constraintVal = null;
+ if (attrUse.getConstraintType() != XSConstants.VC_NONE) {
+ constraintName = (attrUse.getConstraintType() == XSConstants.VC_DEFAULT) ? SchemaSymbols.ATT_DEFAULT : SchemaSymbols.ATT_FIXED;
+ XSValue xsConstraintVal = attrUse.getValueConstraintValue();
+ constraintVal = xsConstraintVal.getNormalizedValue();
+ }
+ String requiredVal = (attrUse.getRequired() == true) ? SchemaSymbols.ATTVAL_REQUIRED : SchemaSymbols.ATTVAL_OPTIONAL;
+ addAttributeToSchemaComponent(document, attrGpDomNode, attrDecl, constraintName, constraintVal, requiredVal);
+ }
+
+ XSWildcard attrWildCard = attrGpDecl.getAttributeWildcard();
+ if (attrWildCard != null) {
+ addWildcardToSchemaComponent(document, attrGpDomNode, (XSWildcardDecl) attrWildCard, SchemaSymbols.ELT_ANYATTRIBUTE);
+ }
+
+ schemaDeclDomNode.appendChild(attrGpDomNode);
+ }
+
+ } // processGlobalAttrGroupDecl
+
+
+ /*
+ * Process global element declarations.
+ */
+ private void processGlobalElementDecl(XSNamedMap globalElemDecls, Document document, Element schemaDeclDomNode) throws DOMException {
+ // iterating global element declarations in the Schema
+ for (int elemIdx = 0; elemIdx < globalElemDecls.size(); elemIdx++) {
+ XSElementDecl elemDecl = (XSElementDecl) globalElemDecls.item(elemIdx);
+ addElementDeclToSchemaComponent(document, schemaDeclDomNode, elemDecl, null, null, true);
+ }
+ } // processGlobalElementDecl
+
+
+ /*
+ * Adding an element declaration to Schema component.
+ */
+ private void addElementDeclToSchemaComponent(Document document, Element parentDomNode, XSElementDecl elemDecl, String minOccurs, String maxOccurs, boolean isGlobal) throws DOMException {
+
+ String elemName = elemDecl.getName();
+ Element elemDeclDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_ELEMENT);
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, elemName);
+
+ // add annotation to an element declaration
+ XSAnnotationImpl elemAnnotation = (XSAnnotationImpl) elemDecl.getAnnotation();
+ if (elemAnnotation != null) {
+ addAnnotationToSchemaComponent(document, elemDeclDomNode, elemAnnotation);
+ }
+
+ XSTypeDefinition typeDef = elemDecl.getTypeDefinition();
+ if (!typeDef.getAnonymous()) {
+ // handling a non-anonymous schema type
+ String typeName = typeDef.getName();
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(typeDef.getNamespace())) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_TYPE, XSD_LANGUAGE_PREFIX + typeName);
+ }
+ else {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_TYPE, typeName);
+ }
+ }
+ else {
+ // handling an anonymous schema type
+ if (typeDef.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
+ XSSimpleTypeDecl simpleTypeDecl = (XSSimpleTypeDecl) typeDef;
+ processSimpleTypeContents(document, elemDeclDomNode, simpleTypeDecl, simpleTypeDecl.getName());
+ }
+ else if (typeDef.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
+ processAnonComplexTypeOnElement(document, elemDeclDomNode, typeDef);
+ }
+ }
+
+ // add possible, minOccurs & maxOccurs attributes
+ if (!isGlobal) {
+ if (minOccurs != null) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_MINOCCURS, minOccurs);
+ }
+ if (maxOccurs != null) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_MAXOCCURS, maxOccurs);
+ }
+ }
+
+ // add "abstract" attribute to xs:element component, if applicable
+ if (elemDecl.getAbstract() == true) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_ABSTRACT, SchemaSymbols.ATTVAL_TRUE);
+ }
+
+ // add "block" attribute to xs:element component, if applicable
+ String blockVal = getElementBlockAttrValue(elemDecl);
+ if (!blockVal.equals("")) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_BLOCK, blockVal);
+ }
+
+ // add "nillable" attribute to xs:element component, if applicable
+ if (elemDecl.getNillable() == true) {
+ elemDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_NILLABLE, SchemaSymbols.ATTVAL_TRUE);
+ }
+
+ // add identity constraint definitions to an 'element declaration'
+ addIDConstraintsToElementDecl(document, elemDecl, elemDeclDomNode);
+
+ parentDomNode.appendChild(elemDeclDomNode);
+
+ } // addElementDeclToSchemaComponent
+
+
+ // construct value of the, "block" attribute for an element declaration.
+ private String getElementBlockAttrValue(XSElementDecl elemDecl) {
+
+ String blockVal = "";
+ boolean blockExt = false;
+ boolean blockRestr = false;
+ boolean blockSubst = false;
+ if (elemDecl.isDisallowedSubstitution(XSConstants.DERIVATION_EXTENSION) == true) {
+ blockExt = true;
+ }
+ if (elemDecl.isDisallowedSubstitution(XSConstants.DERIVATION_RESTRICTION) == true) {
+ blockRestr = true;
+ }
+ if (elemDecl.isDisallowedSubstitution(XSConstants.DERIVATION_SUBSTITUTION) == true) {
+ blockSubst = true;
+ }
+
+ if ((blockExt == true) && (blockRestr == true) && (blockSubst == true)) {
+ blockVal = SchemaSymbols.ATTVAL_POUNDALL;
+ }
+ else {
+ if (blockExt == true) {
+ blockVal = blockVal + SchemaSymbols.ATTVAL_EXTENSION;
+ }
+ if (blockRestr == true) {
+ blockVal = blockVal + " " + SchemaSymbols.ATTVAL_RESTRICTION;
+ }
+ if (blockSubst == true) {
+ blockVal = blockVal + " " + SchemaSymbols.ATTVAL_SUBSTITUTION;
+ }
+ }
+
+ return blockVal;
+
+ } // getElementBlockAttrValue
+
+
+ /*
+ * Add identity constraints to element declaration.
+ */
+ private void addIDConstraintsToElementDecl(Document document, XSElementDecl elemDecl, Element elemDeclDomNode) throws DOMException {
+
+ XSNamedMap idConstraintsMap = elemDecl.getIdentityConstraints();
+
+ // iterate all identity constraints on an element declaration
+ for (int idConsIdx = 0; idConsIdx < idConstraintsMap.getLength(); idConsIdx++) {
+ IdentityConstraint idCons = (IdentityConstraint) idConstraintsMap.item(idConsIdx);
+ String consType = null;
+ String idReferStr = null;
+ if (idCons.getCategory() == XSIDCDefinition.IC_UNIQUE) {
+ consType = SchemaSymbols.ELT_UNIQUE;
+ }
+ else if (idCons.getCategory() == XSIDCDefinition.IC_KEY) {
+ consType = SchemaSymbols.ELT_KEY;
+ }
+ else if (idCons.getCategory() == XSIDCDefinition.IC_KEYREF) {
+ consType = SchemaSymbols.ELT_KEYREF;
+ idReferStr = (((KeyRef) idCons).getKey()).getName();
+ }
+
+ Element idConsDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + consType);
+ String idConsName = idCons.getName();
+ idConsDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, idConsName);
+
+ if (idReferStr != null) {
+ idConsDomNode.setAttributeNS(null, SchemaSymbols.ATT_REFER, idReferStr);
+ }
+
+ // add annotation to an ID constraint
+ XSAnnotationImpl idConsAnnotation = (XSAnnotationImpl) idCons.getAnnotations().item(0);
+ if (idConsAnnotation != null) {
+ addAnnotationToSchemaComponent(document, idConsDomNode, idConsAnnotation);
+ }
+
+ Selector idSelector = idCons.getSelector();
+ String selectorXPathStr = idSelector.getXPath().toString();
+ Element selectorDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_SELECTOR);
+ selectorDomNode.setAttributeNS(null, SchemaSymbols.ATT_XPATH, selectorXPathStr);
+ idConsDomNode.appendChild(selectorDomNode);
+
+ for (int fieldIdx = 0; fieldIdx < idCons.getFieldCount(); fieldIdx++) {
+ Field field = idCons.getFieldAt(fieldIdx);
+ String fieldXpathStr = field.getXPath().toString();
+ Element fieldDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_FIELD);
+ fieldDomNode.setAttributeNS(null, SchemaSymbols.ATT_XPATH, fieldXpathStr);
+ idConsDomNode.appendChild(fieldDomNode);
+ }
+
+ elemDeclDomNode.appendChild(idConsDomNode);
+ }
+
+ } // addIDConstraintsToElementDecl
+
+
+ /*
+ * Process global complex type declarations.
+ */
+ private void processGlobalComplexTypeDecl(XSNamedMap globalComplexTypeDecls, Document document, Element schemaDeclDomNode) throws DOMException {
+
+ // iterating global complex types in the Schema
+ // leaving out built-in Schema type, "anyType" from iteration
+ for (int ctIdx = 0; ctIdx < globalComplexTypeDecls.size() - 1; ctIdx++) {
+ XSComplexTypeDecl complexTypeDecl = (XSComplexTypeDecl) globalComplexTypeDecls.item(ctIdx);
+ String ctName = complexTypeDecl.getName();
+ Element complxTypeDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_COMPLEXTYPE);
+ complxTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, ctName);
+
+ // add annotation to complex type
+ XSAnnotationImpl complexTypeAnnot = (XSAnnotationImpl) complexTypeDecl.getAnnotations().item(0);
+ if (complexTypeAnnot != null) {
+ addAnnotationToSchemaComponent(document, complxTypeDomNode, complexTypeAnnot);
+ }
+
+ addChildrenToComplexType(document, schemaDeclDomNode, complexTypeDecl, complxTypeDomNode);
+ }
+
+ } // processGlobalComplexTypeDecl
+
+
+ /*
+ * Process global simple type declarations.
+ */
+ private void processGlobalSimpleTypeDecl(XSNamedMap globalSimpleTypeDecls, Document document, Element schemaDeclDomNode) throws DOMException {
+ // iterating global simple types in the Schema
+ for (int stIdx = 0; stIdx < globalSimpleTypeDecls.size(); stIdx++) {
+ XSSimpleTypeDecl simpleTypeDecl = (XSSimpleTypeDecl) globalSimpleTypeDecls.item(stIdx);
+ // consider only user defined simple types
+ if (!XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(simpleTypeDecl.getNamespace())) {
+ String stName = simpleTypeDecl.getName();
+ processSimpleTypeContents(document, schemaDeclDomNode, simpleTypeDecl, stName);
+ }
+ }
+ } // processGlobalSimpleTypeDecl
+
+
+ /*
+ * Processing Simple Type contents.
+ */
+ private void processSimpleTypeContents(Document document,Element parentDomNode, XSSimpleTypeDecl simpleTypeDecl, String stName) throws DOMException {
+
+ Element simpleTypeDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_SIMPLETYPE);
+ if (stName != null) {
+ simpleTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, stName);
+ }
+ parentDomNode.appendChild(simpleTypeDomNode);
+
+ // add annotation to a simple type
+ XSAnnotationImpl simpleTypeAnnotation = (XSAnnotationImpl) simpleTypeDecl.getAnnotations().item(0);
+ if (simpleTypeAnnotation != null) {
+ addAnnotationToSchemaComponent(document, simpleTypeDomNode, simpleTypeAnnotation);
+ }
+
+ if (simpleTypeDecl.getVariety() == XSSimpleTypeDefinition.VARIETY_ATOMIC) {
+ Element restrictionDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_RESTRICTION);
+ XSTypeDefinition baseType = simpleTypeDecl.getBaseType();
+ addRestrictionToSimpleContent(document, simpleTypeDecl, simpleTypeDomNode, restrictionDomNode, baseType);
+ }
+ else if (simpleTypeDecl.getVariety() == XSSimpleTypeDefinition.VARIETY_LIST) {
+ XSSimpleTypeDefinition listType = simpleTypeDecl.getItemType();
+ addListDeclToSimpleType(document, simpleTypeDomNode, listType);
+ }
+ else if (simpleTypeDecl.getVariety() == XSSimpleTypeDefinition.VARIETY_UNION) {
+ XSObjectList unionMemberTypes = simpleTypeDecl.getMemberTypes();
+ addUnionDeclToSimpleType(document, simpleTypeDomNode, unionMemberTypes);
+ }
+
+ } // processSimpleTypeContents
+
+
+ /*
+ * Add children to "xs:restriction" for simple contents.
+ */
+ private void addRestrictionToSimpleContent(Document document, XSTypeDefinition typeDefn, Element parentDomNode, Element restrictionDomNode, XSTypeDefinition baseType) throws DOMException {
+
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(baseType.getNamespace())) {
+ restrictionDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, XSD_LANGUAGE_PREFIX + baseType.getName());
+ }
+ else {
+ restrictionDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, baseType.getName());
+ }
+
+ // simple type definition to be used, to get the facets
+ XSSimpleTypeDefinition simpleTypeDefn = null;
+
+ if (typeDefn instanceof XSComplexTypeDefinition) {
+ XSComplexTypeDefinition complexTypeDefn = (XSComplexTypeDefinition) typeDefn;
+ simpleTypeDefn = complexTypeDefn.getSimpleType();
+
+ }
+ else {
+ simpleTypeDefn = (XSSimpleTypeDefinition) typeDefn;
+ }
+
+ // handling single-valued facets
+ XSObjectList facets = simpleTypeDefn.getFacets();
+ for (int facetIdx = 0; facetIdx < facets.getLength(); facetIdx++) {
+ XSFacet facet = (XSFacet) facets.item(facetIdx);
+ Element facetDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + getFacetName(facet.getFacetKind()));
+ facetDomNode.setAttributeNS(null, SchemaSymbols.ATT_VALUE, facet.getLexicalFacetValue());
+ restrictionDomNode.appendChild(facetDomNode);
+ }
+
+ // handling multi-valued Facets ("enumeration" or "pattern")
+ XSObjectList mvFacets = simpleTypeDefn.getMultiValueFacets();
+ for (int mvFacetIdx = 0; mvFacetIdx < mvFacets.getLength(); mvFacetIdx++) {
+ XSMultiValueFacet mvFacet = (XSMultiValueFacet) mvFacets.item(mvFacetIdx);
+ StringList facetValues = mvFacet.getLexicalFacetValues();
+ for (int facValIdex = 0; facValIdex < facetValues.getLength(); facValIdex++) {
+ String facetValue = (String) facetValues.get(facValIdex);
+ Element facetDomNode = null;
+ if (mvFacet.getFacetKind() == XSSimpleTypeDefinition.FACET_ENUMERATION) {
+ facetDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_ENUMERATION);
+ }
+ else if (mvFacet.getFacetKind() == XSSimpleTypeDefinition.FACET_PATTERN) {
+ facetDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_PATTERN);
+ }
+ facetDomNode.setAttributeNS(null, SchemaSymbols.ATT_VALUE, facetValue);
+ restrictionDomNode.appendChild(facetDomNode);
+ }
+ }
+
+ parentDomNode.appendChild(restrictionDomNode);
+
+ } // addRestrictionToSimpleContent
+
+
+ /*
+ * Process global attribute declarations.
+ */
+ private void processGlobalAttrDecl(XSNamedMap globalAttrDecls, Document document, Element schemaDeclDomNode) throws DOMException {
+
+ // iterating global attribute declarations in the Schema
+ for (int attrIdx = 0; attrIdx < globalAttrDecls.size(); attrIdx++) {
+ XSAttributeDecl attrDecl = (XSAttributeDecl) globalAttrDecls.item(attrIdx);
+ String constraintName = null;
+ String constraintVal = null;
+ if (attrDecl.getConstraintType() != XSConstants.VC_NONE) {
+ constraintName = (attrDecl.getConstraintType() == XSConstants.VC_DEFAULT) ? SchemaSymbols.ATT_DEFAULT : SchemaSymbols.ATT_FIXED;
+ constraintVal = attrDecl.getConstraintValue();
+ }
+ addAttributeToSchemaComponent(document, schemaDeclDomNode, attrDecl, constraintName, constraintVal, null);
+ }
+
+ } // processGlobalAttrDecl
+
+
+ /*
+ * Process global group declarations.
+ */
+ private void processGlobalGroupDecl(XSNamedMap globalGroupDecls, Document document, Element schemaDeclDomNode) {
+ // iterating global group declarations in the Schema
+ for (int groupIdx = 0; groupIdx < globalGroupDecls.size(); groupIdx++) {
+ XSGroupDecl groupDecl = (XSGroupDecl) globalGroupDecls.item(groupIdx);
+ addGroupChildToSchemaComponent(document, schemaDeclDomNode, groupDecl, true);
+ }
+ } // processGlobalGroupDecl
+
+
+ /*
+ * Add xs:group child to a Schema component.
+ */
+ private void addGroupChildToSchemaComponent(Document document, Element parentDomNode, XSGroupDecl groupDecl, boolean isGlobal) {
+
+ Element groupDeclDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_GROUP);
+ // add annotation to a group declaration
+ XSAnnotationImpl groupAnnotation = (XSAnnotationImpl) groupDecl.getAnnotation();
+ if (groupAnnotation != null) {
+ addAnnotationToSchemaComponent(document, groupDeclDomNode, groupAnnotation);
+ }
+
+ if (isGlobal) {
+ String groupName = groupDecl.getName();
+ groupDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, groupName);
+ XSModelGroup modelGroup = groupDecl.getModelGroup();
+ if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_SEQUENCE) {
+ addCompositorOnSchemaComponent(document, groupDeclDomNode, modelGroup, SchemaSymbols.ELT_SEQUENCE, "1", "1");
+ }
+ else if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_CHOICE) {
+ addCompositorOnSchemaComponent(document, groupDeclDomNode, modelGroup, SchemaSymbols.ELT_CHOICE, "1", "1");
+ }
+ else if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_ALL) {
+ addAllCompositorOnComplexType(document, groupDeclDomNode, modelGroup, "1", "1");
+ }
+ }
+
+ parentDomNode.appendChild(groupDeclDomNode);
+
+ } // addGroupChildToSchemaComponent
+
+
+ /*
+ * Add attribute declaration to a Schema component (like xs:schema, xs:complexType etc).
+ */
+ private void addAttributeToSchemaComponent(Document document, Element parentDomNode, XSAttributeDecl attrDecl, String constraintName,
+ String constraintVal, String requiredVal) throws DOMException {
+
+ String attrName = attrDecl.getName();
+ Element attrDeclDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_ATTRIBUTE);
+ attrDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_NAME, attrName);
+ parentDomNode.appendChild(attrDeclDomNode);
+
+ // add annotation to attribute declaration
+ XSAnnotationImpl attrAnnotation = (XSAnnotationImpl) attrDecl.getAnnotation();
+ if (attrAnnotation != null) {
+ addAnnotationToSchemaComponent(document, attrDeclDomNode, attrAnnotation);
+ }
+
+ if (constraintName != null) {
+ attrDeclDomNode.setAttributeNS(null, constraintName, constraintVal);
+ }
+
+ if (requiredVal != null) {
+ attrDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_USE, requiredVal);
+ }
+
+ XSTypeDefinition typeDef = attrDecl.getTypeDefinition();
+ if (!typeDef.getAnonymous()) {
+ // handling a non-anonymous schema type
+ String typeName = typeDef.getName();
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(typeDef.getNamespace())) {
+ attrDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_TYPE, XSD_LANGUAGE_PREFIX + typeName);
+ }
+ else {
+ attrDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_TYPE, typeName);
+ }
+ }
+ else {
+ // handling an anonymous schema type
+ XSSimpleTypeDecl simpleTypeDecl = (XSSimpleTypeDecl) typeDef;
+ processSimpleTypeContents(document, attrDeclDomNode, simpleTypeDecl, simpleTypeDecl.getName());
+ }
+
+ } // addAttributeToSchemaComponent
+
+
+ /*
+ * Processing an "anonymous" complex type declaration, on an element.
+ */
+ private void processAnonComplexTypeOnElement(Document document, Element elemDeclDomNode, XSTypeDefinition typeDef) throws DOMException {
+
+ XSComplexTypeDecl complexTypeDecl = (XSComplexTypeDecl) typeDef;
+ Element complexTypeDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_COMPLEXTYPE);
+ // add annotation to a complex type
+ XSAnnotationImpl cmplxTypeAnnotation = (XSAnnotationImpl) complexTypeDecl.getAnnotations().item(0);
+ if (cmplxTypeAnnotation != null) {
+ addAnnotationToSchemaComponent(document, complexTypeDomNode, cmplxTypeAnnotation);
+ }
+
+ addChildrenToComplexType(document, elemDeclDomNode, complexTypeDecl, complexTypeDomNode);
+
+ } // processAnonComplexTypeOnElement
+
+
+ /*
+ * Add child content to complex type declaration.
+ */
+ private void addChildrenToComplexType(Document document, Element parentDomNode, XSComplexTypeDecl complexTypeDecl, Element complexTypeDomNode) throws DOMException {
+
+ // add "abstract" & "mixed" attributes if applicable
+ boolean isAbstract = complexTypeDecl.getAbstract();
+ boolean isMixed = (complexTypeDecl.getContentType() == XSComplexTypeDefinition.CONTENTTYPE_MIXED);
+ if (isAbstract) {
+ complexTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_ABSTRACT, SchemaSymbols.ATTVAL_TRUE);
+ }
+ if (isMixed) {
+ complexTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_MIXED, SchemaSymbols.ATTVAL_TRUE);
+ }
+
+ // add "block" attribute if applicable
+ short prohSubstitutions = complexTypeDecl.getProhibitedSubstitutions();
+ String prohSubsStr = "";
+ if (prohSubstitutions == (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION)) {
+ prohSubsStr = SchemaSymbols.ATTVAL_POUNDALL;
+ }
+ else if (prohSubstitutions == XSConstants.DERIVATION_EXTENSION) {
+ prohSubsStr = SchemaSymbols.ELT_EXTENSION;
+ }
+ else if (prohSubstitutions == XSConstants.DERIVATION_RESTRICTION) {
+ prohSubsStr = SchemaSymbols.ELT_RESTRICTION;
+ }
+ if (!prohSubsStr.equals("")) {
+ complexTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_BLOCK, prohSubsStr);
+ }
+
+ // add "final" attribute if applicable
+ short finalSet = complexTypeDecl.getFinalSet();
+ String finalStr = "";
+ if (finalSet == (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION)) {
+ finalStr = SchemaSymbols.ATTVAL_POUNDALL;
+ }
+ else if (finalSet == XSConstants.DERIVATION_EXTENSION) {
+ finalStr = SchemaSymbols.ELT_EXTENSION;
+ }
+ else if (finalSet == XSConstants.DERIVATION_RESTRICTION) {
+ finalStr = SchemaSymbols.ELT_RESTRICTION;
+ }
+ if (!finalStr.equals("")) {
+ complexTypeDomNode.setAttributeNS(null, SchemaSymbols.ATT_FINAL, finalStr);
+ }
+
+ parentDomNode.appendChild(complexTypeDomNode);
+
+ short derivationMethod = complexTypeDecl.getDerivationMethod();
+
+ if (complexTypeDecl.getContentType() == XSComplexTypeDefinition.CONTENTTYPE_SIMPLE) {
+ // add xs:simpleContent as child of xs:complexType
+ addSimpleContentToComplexType(document, complexTypeDomNode, complexTypeDecl);
+ }
+ else if ((derivationMethod == XSConstants.DERIVATION_RESTRICTION) || (derivationMethod == XSConstants.DERIVATION_EXTENSION)) {
+ if (!XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(complexTypeDecl.getBaseType().getNamespace())) {
+ // add xs:complexContent as child of xs:complexType
+ addComplexContentToComplexType(document, complexTypeDomNode, complexTypeDecl, derivationMethod);
+ }
+ else {
+ XSParticle particle = complexTypeDecl.getParticle();
+ if (particle != null) {
+ processParticleFromComplexType(document, complexTypeDomNode, particle);
+ // add attributes to the complex type
+ addAttributesToComplexType(document, complexTypeDecl, complexTypeDomNode);
+ }
+ else {
+ addAttributesToComplexType(document, complexTypeDecl, complexTypeDomNode);
+ }
+ }
+ }
+
+ } // addChildrenToComplexType
+
+
+ /*
+ * Add xs:simpleContent as child of xs:complexType.
+ */
+ private void addSimpleContentToComplexType(Document document, Element complexTypeDomNode, XSComplexTypeDecl complexTypeDecl) {
+
+ Element simpleContentDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_SIMPLECONTENT);
+ if (complexTypeDecl.getDerivationMethod() == XSConstants.DERIVATION_RESTRICTION) {
+ Element simpleContentRestrDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_RESTRICTION);
+ XSTypeDefinition baseType = complexTypeDecl.getBaseType();
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(baseType.getNamespace())) {
+ simpleContentRestrDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, XSD_LANGUAGE_PREFIX + baseType.getName());
+ }
+ else {
+ simpleContentRestrDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, baseType.getName());
+ }
+
+ addRestrictionToSimpleContent(document, complexTypeDecl, simpleContentDomNode, simpleContentRestrDomNode, complexTypeDecl.getBaseType());
+ addAttributesToComplexType(document, complexTypeDecl, simpleContentRestrDomNode);
+
+ simpleContentDomNode.appendChild(simpleContentRestrDomNode);
+ }
+ else if (complexTypeDecl.getDerivationMethod() == XSConstants.DERIVATION_EXTENSION) {
+ Element simpleContentExtDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_EXTENSION);
+ XSTypeDefinition baseType = complexTypeDecl.getBaseType();
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(baseType.getNamespace())) {
+ simpleContentExtDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, XSD_LANGUAGE_PREFIX + baseType.getName());
+ }
+ else {
+ simpleContentExtDomNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, baseType.getName());
+ }
+ addAttributesToComplexType(document, complexTypeDecl, simpleContentExtDomNode);
+ simpleContentDomNode.appendChild(simpleContentExtDomNode);
+ }
+
+ complexTypeDomNode.appendChild(simpleContentDomNode);
+
+ } // addSimpleContentToComplexType
+
+
+ /*
+ * Add xs:complexContent as child of xs:complexType.
+ */
+ private void addComplexContentToComplexType(Document document, Element complexTypeDomNode, XSComplexTypeDecl complexTypeDecl, short derivationMethod) {
+
+ Element complexContentDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_COMPLEXCONTENT);
+ Element complexContentDerivationNode = null;
+ if (derivationMethod == XSConstants.DERIVATION_RESTRICTION) {
+ complexContentDerivationNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_RESTRICTION);
+ }
+ else if (derivationMethod == XSConstants.DERIVATION_EXTENSION) {
+ complexContentDerivationNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_EXTENSION);
+ }
+
+ if (complexContentDerivationNode != null) {
+ XSTypeDefinition baseType = complexTypeDecl.getBaseType();
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(baseType.getNamespace())) {
+ complexContentDerivationNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, XSD_LANGUAGE_PREFIX + baseType.getName());
+ }
+ else {
+ complexContentDerivationNode.setAttributeNS(null, SchemaSymbols.ATT_BASE, baseType.getName());
+ }
+ complexContentDomNode.appendChild(complexContentDerivationNode);
+ }
+
+ XSParticle particle = complexTypeDecl.getParticle();
+ if (derivationMethod == XSConstants.DERIVATION_EXTENSION) {
+ XSTerm particleTerm = null;
+ if (particle != null) {
+ particleTerm = particle.getTerm();
+ XSModelGroupImpl modelGroup = (XSModelGroupImpl) particleTerm;
+ if (modelGroup.fParticles.length == 2) {
+ particle = modelGroup.fParticles[1];
+ }
+ }
+ }
+
+ if (particle != null) {
+ processParticleFromComplexType(document, complexContentDerivationNode, particle);
+ }
+
+ addAttributesToComplexType(document, complexTypeDecl, complexContentDerivationNode);
+
+ complexTypeDomNode.appendChild(complexContentDomNode);
+
+ } // addComplexContentToComplexType
+
+
+ /*
+ * Add attributes to the complex type.
+ */
+ private void addAttributesToComplexType(Document document, XSComplexTypeDecl complexTypeDecl, Element parentDomNode) throws DOMException {
+
+ // iterate all attributes on the complex type. all attributes on a complex type (from all-of
+ // it's xs:attribute & xs:attributeGroup declarations) are expanded, into an XSObjectList list.
+ XSObjectList attributeUses = complexTypeDecl.getAttributeUses();
+ for (int attrUsesIdx = 0; attrUsesIdx < attributeUses.getLength(); attrUsesIdx++) {
+ XSAttributeUse attrUse = (XSAttributeUse) attributeUses.item(attrUsesIdx);
+ String constraintName = null;
+ String constraintVal = null;
+ if (attrUse.getConstraintType() != XSConstants.VC_NONE) {
+ constraintName = (attrUse.getConstraintType() == XSConstants.VC_DEFAULT) ? SchemaSymbols.ATT_DEFAULT : SchemaSymbols.ATT_FIXED;
+ XSValue xsConstraintVal = attrUse.getValueConstraintValue();
+ constraintVal = xsConstraintVal.getNormalizedValue();
+ }
+
+ String requiredVal = (attrUse.getRequired() == true) ? SchemaSymbols.ATTVAL_REQUIRED : SchemaSymbols.ATTVAL_OPTIONAL;
+ XSAttributeDecl attrDecl = (XSAttributeDecl) attrUse.getAttrDeclaration();
+ XSComplexTypeDefinition enclosingCTDefn = attrDecl.getEnclosingCTDefinition();
+ boolean complexTypesIdentical = (enclosingCTDefn == null) ? false : XSTypeHelper.isSchemaTypesIdentical(complexTypeDecl, enclosingCTDefn);
+ // do not add attributes, from the base type. they will be serialized as part of the base type serialization.
+ if (complexTypesIdentical) {
+ addAttributeToSchemaComponent(document, parentDomNode, attrDecl, constraintName, constraintVal, requiredVal);
+ }
+ }
+
+ } // addAttributesToComplexType
+
+
+ /*
+ * Processing a "particle" from a complex type.
+ */
+ private void processParticleFromComplexType(Document document, Element parentDomNode, XSParticle particle) throws DOMException {
+
+ XSTerm particleTerm = particle.getTerm();
+
+ if (particleTerm instanceof XSModelGroup) {
+ XSModelGroup modelGroup = (XSModelGroup) particleTerm;
+ String minOccurs = getMinOccursVal(particle);
+ String maxOccurs = getMaxOccursVal(particle);
+ if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_SEQUENCE) {
+ addCompositorOnSchemaComponent(document, parentDomNode, modelGroup, SchemaSymbols.ELT_SEQUENCE, minOccurs, maxOccurs);
+ }
+ else if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_CHOICE) {
+ addCompositorOnSchemaComponent(document, parentDomNode, modelGroup, SchemaSymbols.ELT_CHOICE, minOccurs, maxOccurs);
+ }
+ else if (modelGroup.getCompositor() == XSModelGroup.COMPOSITOR_ALL) {
+ addAllCompositorOnComplexType(document, parentDomNode, modelGroup, minOccurs, maxOccurs);
+ }
+ }
+
+ } // processParticleFromComplexType
+
+
+ /*
+ * Adding a "sequence" or "choice" compositor on a complex type.
+ */
+ private void addCompositorOnSchemaComponent(Document document, Element parentDomNode, XSModelGroup modelGroup, String compositor, String minOccurs, String maxOccurs) throws DOMException {
+
+ Element compositorDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + compositor);
+ // add minOccurs & maxOccurs attributes to the compositor root
+ if (minOccurs != null && !minOccurs.equals("1")) {
+ compositorDomNode.setAttributeNS(null, SchemaSymbols.ATT_MINOCCURS, minOccurs);
+ }
+ if (maxOccurs != null && !maxOccurs.equals("1")) {
+ compositorDomNode.setAttributeNS(null, SchemaSymbols.ATT_MAXOCCURS, maxOccurs);
+ }
+
+ XSObjectList compositorChildren = modelGroup.getParticles();
+ for (int seqIdx = 0; seqIdx < compositorChildren.getLength(); seqIdx++) {
+ XSObject seqItem = compositorChildren.item(seqIdx);
+ XSParticle compositorParticle = (XSParticle) seqItem;
+ String minOccursParticle = getMinOccursVal(compositorParticle);
+ String maxOccursParticle = getMaxOccursVal(compositorParticle);
+ XSTerm partclTerm = compositorParticle.getTerm();
+ if (partclTerm instanceof XSElementDeclaration) {
+ XSElementDecl elemDecl = (XSElementDecl) partclTerm;
+ addElementDeclToSchemaComponent(document, compositorDomNode, elemDecl, minOccursParticle, maxOccursParticle, false);
+ }
+ else if (partclTerm instanceof XSModelGroup) {
+ // recursively adding model groups
+ XSModelGroup partlModelGroup = (XSModelGroup) partclTerm;
+ if (partlModelGroup.getCompositor() == XSModelGroup.COMPOSITOR_CHOICE) {
+ addCompositorOnSchemaComponent(document, compositorDomNode, partlModelGroup, SchemaSymbols.ELT_CHOICE, minOccursParticle, maxOccursParticle);
+ }
+ else if (partlModelGroup.getCompositor() == XSModelGroup.COMPOSITOR_SEQUENCE) {
+ addCompositorOnSchemaComponent(document, compositorDomNode, partlModelGroup, SchemaSymbols.ELT_SEQUENCE, minOccursParticle, maxOccursParticle);
+ }
+ }
+ else if (partclTerm instanceof XSWildcard) {
+ addWildcardToSchemaComponent(document, compositorDomNode, (XSWildcardDecl) partclTerm, SchemaSymbols.ELT_ANY);
+ }
+ }
+
+ parentDomNode.appendChild(compositorDomNode);
+
+ } // addCompositorOnSchemaComponent
+
+
+ /*
+ * Processing an "all" declaration on a complex type.
+ */
+ private void addAllCompositorOnComplexType(Document document, Element complxTypeDomNode, XSModelGroup modelGroup, String minOccurs, String maxOccurs) throws DOMException {
+
+ Element allDeclDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_ALL);
+ // add minOccurs & maxOccurs attributes to the compositor root
+ if (minOccurs != null && !minOccurs.equals("1")) {
+ allDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_MINOCCURS, minOccurs);
+ }
+ if (maxOccurs != null && !maxOccurs.equals("1")) {
+ allDeclDomNode.setAttributeNS(null, SchemaSymbols.ATT_MAXOCCURS, maxOccurs);
+ }
+
+ XSObjectList modelParticles = modelGroup.getParticles();
+ for (int prtclIdx = 0; prtclIdx < modelParticles.getLength(); prtclIdx++) {
+ XSParticle partclItem = (XSParticle) modelParticles.item(prtclIdx);
+ String minOccursParticle = getMinOccursVal(partclItem);
+ String maxOccursParticle = getMaxOccursVal(partclItem);
+ XSTerm partclTerm = partclItem.getTerm();
+ if (partclTerm instanceof XSElementDeclaration) {
+ addElementDeclToSchemaComponent(document, allDeclDomNode, (XSElementDecl) partclTerm, minOccursParticle, maxOccursParticle, false);
+ }
+ else if (partclTerm instanceof XSWildcard) {
+ XSWildcardDecl wildCardDecl = (XSWildcardDecl) partclTerm;
+ addWildcardToSchemaComponent(document, allDeclDomNode, wildCardDecl, SchemaSymbols.ELT_ANY);
+ }
+ }
+
+ complxTypeDomNode.appendChild(allDeclDomNode);
+
+ } // addAllCompositorOnComplexType
+
+
+ /*
+ * Adding wild-card to a Schema component.
+ */
+ private void addWildcardToSchemaComponent(Document document, Element parentNode, XSWildcardDecl wildCardDecl, String wildCardType) {
+ Element wildCardDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + wildCardType);
+ String processContentsVal = wildCardDecl.getProcessContentsAsString();
+ if (!processContentsVal.equals(SchemaSymbols.ATTVAL_STRICT)) {
+ wildCardDomNode.setAttributeNS(null, SchemaSymbols.ATT_PROCESSCONTENTS, processContentsVal);
+ }
+ parentNode.appendChild(wildCardDomNode);
+ } // addWildcardToSchemaComponent
+
+
+ /*
+ * Add xs:list as child of xs:simpleType.
+ */
+ private void addListDeclToSimpleType(Document document, Element simpleTypeDomNode, XSSimpleTypeDefinition listType) {
+
+ Element listDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ELT_LIST);
+ simpleTypeDomNode.appendChild(listDomNode);
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(listType.getNamespace())) {
+ listDomNode.setAttributeNS(null, SchemaSymbols.ATT_ITEMTYPE, XSD_LANGUAGE_PREFIX + listType.getName());
+ }
+ else {
+ if (listType.getName() != null) {
+ listDomNode.setAttributeNS(null, SchemaSymbols.ATT_ITEMTYPE, listType.getName());
+ }
+ else {
+ // add xs:simpleType as child of, xs:list
+ XSSimpleTypeDecl simpleTypeDeclOfList = (XSSimpleTypeDecl) listType;
+ processSimpleTypeContents(document, listDomNode, simpleTypeDeclOfList, simpleTypeDeclOfList.getName());
+ }
+ }
+
+ } // addListDeclToSimpleType
+
+
+ /*
+ * Add xs:union as child of xs:simpleType.
+ */
+ private void addUnionDeclToSimpleType(Document document, Element simpleTypeDomNode, XSObjectList unionMemberTypes) {
+
+ Element unionDomNode = document.createElementNS(XSD_LANGUAGE_URI, XSD_LANGUAGE_PREFIX + SchemaSymbols.ATTVAL_UNION);
+ simpleTypeDomNode.appendChild(unionDomNode);
+
+ String memberTypesStr = "";
+ for (int unionTypeListIdx = 0; unionTypeListIdx < unionMemberTypes.getLength(); unionTypeListIdx++) {
+ XSSimpleTypeDecl memberType = (XSSimpleTypeDecl) unionMemberTypes.item(unionTypeListIdx);
+ if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(memberType.getNamespace())) {
+ memberTypesStr = memberTypesStr + " " + XSD_LANGUAGE_PREFIX + memberType.getName();
+ }
+ else {
+ if (memberType.getName() != null) {
+ memberTypesStr = memberTypesStr + " " + memberType.getName();
+ }
+ else {
+ // add xs:simpleType as child of, xs:union
+ XSSimpleTypeDecl simpleTypeDeclOfUnion = (XSSimpleTypeDecl) memberType;
+ processSimpleTypeContents(document, unionDomNode, simpleTypeDeclOfUnion, simpleTypeDeclOfUnion.getName());
+ }
+ }
+ }
+
+ if (!memberTypesStr.equals("")) {
+ // discard a blank space character, at the beginning
+ memberTypesStr = memberTypesStr.substring(1);
+ unionDomNode.setAttributeNS(null, SchemaSymbols.ATT_MEMBERTYPES, memberTypesStr);
+ }
+
+ } // addUnionDeclToSimpleType
+
+
+ /*
+ * Add annotation to a schema component.
+ */
+ private void addAnnotationToSchemaComponent(Document document, Element parentDomNode, XSAnnotationImpl annotation) throws DOMException {
+
+ String annotString = annotation.getAnnotationString();
+ StringReader annotationReader = new StringReader(annotString);
+ InputSource annotationInputSrc = new InputSource(annotationReader);
+ DocumentBuilderFactory annotationDbf = DocumentBuilderFactory.newInstance();
+ Element annotationElement = null;
+ try {
+ DocumentBuilder annotationDb = annotationDbf.newDocumentBuilder();
+ Document annotationDom = annotationDb.parse(annotationInputSrc);
+ annotationElement = (Element) document.importNode(annotationDom.getDocumentElement(), true);
+ }
+ catch(Exception ex) {
+ ex.printStackTrace();
+ }
+
+ parentDomNode.appendChild(annotationElement);
+
+ } // addAnnotationToSchemaComponent
+
+
+ /*
+ * Get name of a facet given it's kind.
+ */
+ private String getFacetName(short facetKind) {
+
+ if (facetKind == XSSimpleTypeDefinition.FACET_MINEXCLUSIVE) {
+ return SchemaSymbols.ELT_MINEXCLUSIVE;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_MININCLUSIVE) {
+ return SchemaSymbols.ELT_MININCLUSIVE;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_MAXEXCLUSIVE) {
+ return SchemaSymbols.ELT_MAXEXCLUSIVE;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_MAXINCLUSIVE) {
+ return SchemaSymbols.ELT_MAXINCLUSIVE;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_TOTALDIGITS) {
+ return SchemaSymbols.ELT_TOTALDIGITS;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_FRACTIONDIGITS) {
+ return SchemaSymbols.ELT_FRACTIONDIGITS;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_LENGTH) {
+ return SchemaSymbols.ELT_LENGTH;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_MINLENGTH) {
+ return SchemaSymbols.ELT_MINLENGTH;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_MAXLENGTH) {
+ return SchemaSymbols.ELT_MAXLENGTH;
+ }
+ else if (facetKind == XSSimpleTypeDefinition.FACET_WHITESPACE) {
+ return SchemaSymbols.ELT_WHITESPACE;
+ }
+
+ // unreach
+ return null;
+
+ } // getFacetName
+
+
+ /*
+ * Given an XSD particle, get it's minOccurs value as a String.
+ */
+ private String getMinOccursVal(XSParticle particle) {
+ String minOccursStr = null;
+ int minOccurs = particle.getMinOccurs();
+ if (minOccurs != 1) {
+ minOccursStr = String.valueOf(minOccurs);
+ }
+ return minOccursStr;
+ } // getMinOccursVal
+
+
+ /*
+ * Given an XSD particle, get it's maxOccurs value as a String.
+ */
+ private String getMaxOccursVal(XSParticle particle) {
+ String maxOccursStr = null;
+ if (particle.getMaxOccursUnbounded()) {
+ maxOccursStr = SchemaSymbols.ATTVAL_UNBOUNDED;
+ }
+ else {
+ int maxOccurs = particle.getMaxOccurs();
+ if (maxOccurs != 1) {
+ maxOccursStr = String.valueOf(maxOccurs);
+ }
+ }
+ return maxOccursStr;
+ } // getMaxOccursVal
+
+} // class XSSerializer
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@xerces.apache.org
For additional commands, e-mail: commits-help@xerces.apache.org