Package org.apache.ws.jaxme.xs.impl

Source Code of org.apache.ws.jaxme.xs.impl.XSLogicalParser$SubstitutionGroup

/*
* Copyright 2003, 2004  The Apache Software Foundation
*
* Licensed 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 org.apache.ws.jaxme.xs.impl;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.ws.jaxme.xs.XSContentHandler;
import org.apache.ws.jaxme.xs.XSElement;
import org.apache.ws.jaxme.xs.XSObjectFactory;
import org.apache.ws.jaxme.xs.XSParser;
import org.apache.ws.jaxme.xs.XSSchema;
import org.apache.ws.jaxme.xs.parser.XSContext;
import org.apache.ws.jaxme.xs.parser.XsSAXParser;
import org.apache.ws.jaxme.xs.parser.impl.LocSAXException;
import org.apache.ws.jaxme.xs.xml.XsAnyURI;
import org.apache.ws.jaxme.xs.xml.XsEAnnotation;
import org.apache.ws.jaxme.xs.xml.XsEImport;
import org.apache.ws.jaxme.xs.xml.XsEInclude;
import org.apache.ws.jaxme.xs.xml.XsENotation;
import org.apache.ws.jaxme.xs.xml.XsERedefine;
import org.apache.ws.jaxme.xs.xml.XsESchema;
import org.apache.ws.jaxme.xs.xml.XsETopLevelSimpleType;
import org.apache.ws.jaxme.xs.xml.XsNCName;
import org.apache.ws.jaxme.xs.xml.XsObject;
import org.apache.ws.jaxme.xs.xml.XsObjectFactory;
import org.apache.ws.jaxme.xs.xml.XsQName;
import org.apache.ws.jaxme.xs.xml.XsRedefinable;
import org.apache.ws.jaxme.xs.xml.XsTAttribute;
import org.apache.ws.jaxme.xs.xml.XsTAttributeGroup;
import org.apache.ws.jaxme.xs.xml.XsTComplexType;
import org.apache.ws.jaxme.xs.xml.XsTLocalElement;
import org.apache.ws.jaxme.xs.xml.XsTNamedGroup;
import org.apache.ws.jaxme.xs.xml.XsTSimpleExplicitGroup;
import org.apache.ws.jaxme.xs.xml.XsTTopLevelElement;
import org.w3c.dom.Node;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;


/** <p>Implementation of a logical parser.</p>
*
* @author <a href="mailto:joe@ispsoft.de">Jochen Wiedmann</a>
*/
public class XSLogicalParser {
    /** This class allows to predefine schemas that are imported
     * implicitly. This is required, for example, when processing
     * SOAP schemas, which assume the predefined SOAP types.
     */
  public static class AddedImport {
    private final String namespace;
    private final String schemaLocation;
    private final Node node;
    private boolean isImported;
   
    /** Creates a new implicit schema import for the namespace
         * URI <code>pNamespace</code>. The schema is loaded from
         * the URL <code>pSchemaLocation</code>.
     */
        public AddedImport(String pNamespace, String pSchemaLocation) {
      namespace = pNamespace;
      schemaLocation = pSchemaLocation;
      node = null;
    }
        /** Creates a new implicit schema import for the namespace
         * URI <code>pNamespace</code>. The schema is loaded from
         * the DOM node <code>pNode</code>.
         */
    public AddedImport(String pNamespace, Node pNode) {
      if (pNode == null) {
        throw new NullPointerException("The node argument must not be null.");
      }
      namespace = pNamespace;
      schemaLocation = null;
      node = pNode;
    }
   
    /** Returns whether the import was already processed.
     */
        public boolean isImported() {
      return isImported;
    }

        /** Sets whether the import was already processed.
         */
    public void setImported(boolean pIsImported) {
      isImported = pIsImported;
    }

        /** Returns the namespace URI of the imported schema.
         */
    public String getNamespace() {
      return namespace;
    }

        /** Returns the URL, from which the schema is being loaded.
         * Returns null, if the schema is loaded from a DOM node.
         */
        public String getSchemaLocation() {
      return schemaLocation;
    }

        /** Returns the DOM node, from which the schema is being loaded.
         * Returns null, if the schema is loaded from an URL.
         */
    public Node getNode() {
      return node;
    }
  }

  private boolean notValidating;
  private List syntaxSchemas = new ArrayList();
  private XsESchema[] syntaxSchemaArray;
  private XSSchema schema;
  private Set importedSchemas;
  private List addedImports = new ArrayList();

  protected XSContext getData() {
    return XSParser.getRunningInstance().getContext();
  }

  /** <p>Sets whether the parser is validating.</p>
   */
  public void setValidating(boolean pValidating) {
    notValidating = !pValidating;
  }

  /** <p>Returns whether the parser is validating.</p>
   */
  public boolean isValidating() {
    return !notValidating;
  }

  /** <p>Adds a schema being imported by the parser. This feature
   * is useful, if a schema silently assumes the presence of additional
   * datatypes. For example, a WSDL definition will contain references
   * to SOAP datatypes without explicit import.</p>
   * <p>In practice, the declaration will silently create an
   * "xs:import" node.</p>
   * @param pNamespace Matches the "xs:import" nodes "namespace" attribute.
   *   In particular it may be null, in which case the imported schema may
   *   not have a targetNamespace.
   * @param pSchemaLocation Matches the "xs:import" nodes "schemaLocation"
   *   attribute. In particular it may be null.
   */
  public void addImport(String pNamespace, String pSchemaLocation) {
    addedImports.add(new AddedImport(pNamespace, pSchemaLocation));
  }

  /** <p>Adds a schema being imported by the parser. The schema is
   * provided as a DOM node. This feature is useful, if a schema
   * silently assumes the presence of additional datatypes. For
   * example, a WSDL definition will contain references to SOAP
   * datatypes without explicit import.</p>
   * @param pNamespace Matches the "xs:import" nodes "namespace"
   *   attribute. In particular it may be null, in which case the
   *   imported schema may not have a targetNamespace.
   * @param pSchema A DOM node with the schema being imported.
   */
  public void addImport(String pNamespace, Node pSchema) {
    addedImports.add(new XSLogicalParser.AddedImport(pNamespace, pSchema));
  }

  /** <p>Returns the array of added imports, typically empty.</p>
   */
  public AddedImport[] getAddedImports() {
    return (AddedImport[]) addedImports.toArray(new AddedImport[addedImports.size()]);
  }

  /** <p>Returns the schema, which is currently being parsed.</p>
   */
  public XSSchema getSchema() { return schema; }

  /** <p>Sets the schema, which is currently being parsed.</p>
   */
  protected void setSchema(XSSchema pSchema) {
    schema = pSchema;
  }

  protected XsESchema parseSyntax(Node pNode) throws SAXException {
    XSContext data = getData();
    try {
      XsObjectFactory factory = data.getXsObjectFactory();
      XsESchema mySchema = factory.newXsESchema();
      XsSAXParser xsSAXParser = factory.newXsSAXParser(mySchema);
      addSyntaxSchema(mySchema);
      try {
        data.setCurrentContentHandler(xsSAXParser);
        DOMSerializer ds = new DOMSerializer();
        ds.serialize(pNode, xsSAXParser);
        return (XsESchema) xsSAXParser.getBean();
      } finally {
        removeSyntaxSchema();
      }
    } finally {
      data.setCurrentContentHandler(null);
    }
  }

  /** <p>Converts the given URI into an instance of InputSource.</p>
   */
  protected InputSource getInputSource(String pReferencingSystemId, String pURI) throws SAXException {
    URL url = null;
    if (pReferencingSystemId != null) {
      // Try to create the new URI based on the old URI; may be its relative?
      try {
        url = new URL(new URL(pReferencingSystemId), pURI);
      } catch (MalformedURLException e) {
      }

      if (url == null) {
        try {
          url = new File(new File(pReferencingSystemId).getParentFile(), pURI).toURL();
        } catch (MalformedURLException e) {
        }
      }
    }

    if (url == null) {
      try {
        url = new URL(pURI);
      } catch (MalformedURLException e) {
        try {
          url = new File(pURI).toURL();
        } catch (MalformedURLException f) {
          throw new SAXException("Failed to parse the URI " + pURI);
        }
      }
    }

    try {
      InputSource isource = new InputSource(url.openStream());
      isource.setSystemId(url.toString());
      return isource;
    } catch (IOException e) {
      throw new SAXException("Failed to open the URL " + url, e);
    }
  }


  protected XsESchema parseSyntax(Locator pLocator, String pSchemaLocation)
        throws SAXException, IOException, ParserConfigurationException {
      XsESchema result = getData().getXsObjectFactory().newXsESchema();
      parseSyntax(pLocator, pSchemaLocation, result);
      return result;
  }

  protected void parseSyntax(Locator pLocator, String pSchemaLocation,
                     XsESchema pSchema)
      throws SAXException, IOException, ParserConfigurationException {
    XSContext data = getData();
    try {
        XsObjectFactory factory = data.getXsObjectFactory();
        XMLReader xr = factory.newXMLReader(isValidating());
        EntityResolver entityResolver = xr.getEntityResolver();
        InputSource schemaSource = null;
        if (entityResolver != null) {
            schemaSource = entityResolver.resolveEntity(null, pSchemaLocation);
        }
        if (schemaSource == null) {
            schemaSource = getInputSource(pLocator == null ? null : pLocator.getSystemId(),
                                pSchemaLocation);
        }

        XsSAXParser xsSAXParser = factory.newXsSAXParser(pSchema);
        addSyntaxSchema(pSchema);
        try {
            data.setCurrentContentHandler(xsSAXParser);
            xr.setContentHandler(xsSAXParser);
            xr.parse(schemaSource);
        } finally {
            removeSyntaxSchema();
        }
    } finally {
      data.setCurrentContentHandler(null);
    }
  }

  /** <p>Redefines the given {@link XsRedefinable}.</p>
   */
  protected void redefine(XsESchema pSyntaxSchema,
                            XsERedefine pRedefine, XsRedefinable pChild) throws SAXException {
    XSSchema mySchema = getSchema();
    XSContext data = getData();
    XSObjectFactory factory = data.getXSObjectFactory();
    if (pChild instanceof XsTAttributeGroup) {
      XsTAttributeGroup attributeGroup = (XsTAttributeGroup) pChild;
      mySchema.redefine(factory.newXSAttributeGroup(mySchema, attributeGroup));
    } else if (pChild instanceof XsTNamedGroup) {
      XsTNamedGroup group = (XsTNamedGroup) pChild;
      mySchema.redefine(factory.newXSGroup(mySchema, group));
    } else if (pChild instanceof XsETopLevelSimpleType) {
      XsETopLevelSimpleType type = (XsETopLevelSimpleType) pChild;
      mySchema.redefine(factory.newXSType(mySchema, type));
    } else if (pChild instanceof XsTComplexType) {
      XsTComplexType type = (XsTComplexType) pChild;
      mySchema.redefine(factory.newXSType(mySchema, type));
    } else {
      Locator locator = (pChild instanceof XsObject) ? ((XsObject) pChild).getLocator() : pRedefine.getLocator();
      throw new LocSAXException("Unknown type for redefinition: " + pChild.getClass().getName() +
                                   ", perhaps you should handle this in a subclass?", locator);
    }
  }



  /** <p>Adds the given object to the schema.</p>
   *
   */
  protected void add(XsESchema pSyntaxSchema, Object pChild) throws SAXException {
    XSSchema mySchema = getSchema();
    XSContext data = getData();
    XSObjectFactory factory = data.getXSObjectFactory();
    if (pChild instanceof XsEAnnotation) {
      XsEAnnotation annotation = (XsEAnnotation) pChild;
      mySchema.add(factory.newXSAnnotation(mySchema, annotation));
    } else if (pChild instanceof XsETopLevelSimpleType) {
      XsETopLevelSimpleType type = (XsETopLevelSimpleType) pChild;
      mySchema.add(factory.newXSType(mySchema, type));
    } else if (pChild instanceof XsTComplexType) {
      XsTComplexType type = (XsTComplexType) pChild;
      mySchema.add(factory.newXSType(mySchema, type));
    } else if (pChild instanceof XsTNamedGroup) {
      XsTNamedGroup group = (XsTNamedGroup) pChild;
      mySchema.add(factory.newXSGroup(mySchema, group));
    } else if (pChild instanceof XsTAttributeGroup) {
      XsTAttributeGroup attributeGroup = (XsTAttributeGroup) pChild;
      mySchema.add(factory.newXSAttributeGroup(mySchema, attributeGroup));
    } else if (pChild instanceof XsTTopLevelElement) {
      XsTTopLevelElement element = (XsTTopLevelElement) pChild;
      mySchema.add(factory.newXSElement(mySchema, element));
    } else if (pChild instanceof XsTAttribute) {
      XsTAttribute attribute = (XsTAttribute) pChild;
      mySchema.add(factory.newXSAttribute(mySchema, attribute));
    } else if (pChild instanceof XsENotation) {
      XsENotation notation = (XsENotation) pChild;
      mySchema.add(factory.newXSNotation(mySchema, notation));
    } else {
      Locator locator = (pChild instanceof XsObject) ?
        ((XsObject) pChild).getLocator() : pSyntaxSchema.getLocator();
      throw new LocSAXException("Unknown child type: " + pChild.getClass().getName() +
                                   ", perhaps you should handle this in a subclass?", locator);
    }
  }

  /** <p>Handles xs:refefine.</p>
   */
  protected void redefineSchema(XsESchema pRedefiningSchema,
                                  XsERedefine pRedefine)
      throws SAXException, IOException, ParserConfigurationException {
    // TODO: Implement redefine
    throw new LocSAXException("Redefine isn't yet implemented.", pRedefine.getLocator());
  }

  /** <p>Handles xs:include.</p>
   */
  protected void includeSchema(XsESchema pIncludingSchema,
                               XsEInclude pInclude)
      throws SAXException, IOException, ParserConfigurationException {
    XsAnyURI schemaLocation = pInclude.getSchemaLocation();
    if (schemaLocation == null) {
      throw new LocSAXException("Invalid include: Missing 'schemaLocation' attribute.",
                                   pInclude.getLocator());
    }
    Locator locator = pInclude.getLocator();
    XsESchema includedSchema = parseSyntax(locator, schemaLocation.toString());
    XsAnyURI incNamespace = includedSchema.getTargetNamespace();
    if (incNamespace == null) {
        if (pIncludingSchema.getTargetNamespace() != null) {
            includedSchema.setTargetNamespace(pIncludingSchema.getTargetNamespace());
        }
    } else {
        XsAnyURI myNamespace = includedSchema.getTargetNamespace();
        if (!incNamespace.equals(myNamespace)) {
            throw new LocSAXException("Invalid include: The included schemas target namespace " +
                    incNamespace + " and the including schemas target namespace " +
                    myNamespace + " do not match.",
                    pInclude.getLocator());
        }
    }
    parse(includedSchema);
  }

  private void checkValidImportSchema(XsESchema pImportingSchema, String pNamespace,
                                        Locator pLocator)
      throws SAXException {
    if (pNamespace == null) {
      if (pImportingSchema.getTargetNamespace() == null) {
        throw new LocSAXException("The importing schema has no 'targetNamespace' attribute and" +
                                     " the 'import' element has no 'namespace' attribute, which is" +
                                     " forbidden. Perhaps you want to use include?",
                                     pLocator);
      }
    } else {
      if ("".equals(pNamespace)) {
        throw new LocSAXException("Invalid import: Empty 'namespace' attribute, which is forbidden." +
                                   " Perhaps you want to omit the attribute to indicate the absence of a namespace?",
                                   pLocator);
      }
      XsAnyURI targetNamespace = pImportingSchema.getTargetNamespace();
      if (targetNamespace != null  &&
          pNamespace.equals(targetNamespace.toString())) {
        throw new LocSAXException("The importing schema and the imported schema have the same namespace, which is forbidden. Perhaps you want to use include?",
                                   pLocator);
      }
    }
  }

  private void importSchema(XsESchema pImportingSchema, String pNamespace,
                            XsESchema pImportedSchema, Locator pLocator)
      throws SAXException, ParserConfigurationException, IOException {
    XsAnyURI impNamespace = pImportedSchema.getTargetNamespace();
    if (pNamespace == null) {
      if (impNamespace != null) {
        throw new LocSAXException("The 'import' element does not have a 'namespace' attribute, but the imported schema has target namespace " +
                                     impNamespace + ", it ought to match and have none.",
                                     pLocator);
      }
    } else {
      if (impNamespace == null) {
        throw new LocSAXException("The 'import' element has a 'namespace' attribute (" + pNamespace +
                                   "), but the imported schema has no 'targetNamespace' attribute.",
                                   pLocator);
      } else if (!pNamespace.equals(impNamespace.toString())) {
        throw new LocSAXException("The 'import' elements 'namespace' attribute (" + pNamespace +
                                     ") and the imported schemas 'targetNamespace' attribute (" +
                                     impNamespace + ") do not match.",
                                     pLocator);
      }
    }
    parse(pImportedSchema);
  }

  /** <p>Handles xs:import.</p>
   */
  protected void importSchema(XsESchema pImportingSchema,
                              String pNamespace, String pSchemaLocation,
                              Locator pLocator)
      throws SAXException, IOException, ParserConfigurationException {
    if (pSchemaLocation == null) {
      return;
    }
    checkValidImportSchema(pImportingSchema, pNamespace, pLocator);

    if (importedSchemas != null  &&  importedSchemas.contains(pSchemaLocation)) {
      // Already imported, do not import again
      return;
    }
    if (importedSchemas == null) {
      importedSchemas = new HashSet();
    }
    importedSchemas.add(pSchemaLocation);
    XsESchema importedSchema = parseSyntax(pLocator, pSchemaLocation);
    importSchema(pImportingSchema, pNamespace, importedSchema, pLocator);
  }

  protected void importSchema(XsESchema pImportingSchema, String pNamespace, Node pNode)
      throws SAXException, IOException, ParserConfigurationException {
    checkValidImportSchema(pImportingSchema, pNamespace, null);
    XsESchema importedSchema = parseSyntax(pNode);
    importSchema(pImportingSchema, pNamespace, importedSchema, null);
  }

  /** <p>Parses the given {@link InputSource} syntactically and
   * converts the objects that it finds into logical objects.
   * These logical objects are added to the given {@link XSSchema}.</p>
   */
  protected void parse(XsESchema pSyntaxSchema)
      throws ParserConfigurationException, SAXException, IOException {
    addSyntaxSchema(pSyntaxSchema);
    try {
      for (int i = 0;  i < addedImports.size();  i++) {
        AddedImport addedImport = (AddedImport) addedImports.get(i);
        if (!addedImport.isImported()) {
          addedImport.setImported(true);
          Node node = addedImport.getNode();
          if (node == null) {
            importSchema(pSyntaxSchema, addedImport.getNamespace(),
                         addedImport.getSchemaLocation(), null);
          } else {
            importSchema(pSyntaxSchema, addedImport.getNamespace(), node);
          }
        }
      }
      Object[] childs = pSyntaxSchema.getChilds();

      for (int i = 0;  i < childs.length;  i++) {
        Object o = childs[i];
        if (o instanceof XsEInclude) {
          includeSchema(pSyntaxSchema, (XsEInclude) o);
        } else if (o instanceof XsERedefine) {
          redefineSchema(pSyntaxSchema, (XsERedefine) o);
        } else if (o instanceof XsEImport) {
          XsEImport xsEImport = (XsEImport) o;
          XsAnyURI namespace = xsEImport.getNamespace();
          XsAnyURI schemaLocation = xsEImport.getSchemaLocation();
          importSchema(pSyntaxSchema, namespace == null ? null : namespace.toString(),
                       schemaLocation == null ? null : schemaLocation.toString(),
                       xsEImport.getLocator());
        } else {
          add(pSyntaxSchema, childs[i]);
        }
      }
    } finally {
      removeSyntaxSchema();
    }
  }


  private static class SubstitutionGroup {
    private final List members = new ArrayList();
    private final XSElement head;

    public SubstitutionGroup(XSElement pHead) {
      head = pHead;
    }
    public XSElement getHead() { return head; }
    public XSElement[] getMembers() {
      return (XSElement[]) members.toArray(new XSElement[members.size()]);
    }
    public void addMember(XSElement pElement) {
      members.add(pElement);
    }
  }

  protected void createSubstitutionGroups(XSSchema pSchema) throws SAXException {
    Object[] myChilds = pSchema.getChilds();

    // Build the Map of substitution groups.
    Map substitutionGroups = new HashMap();
    for (int i = 0;  i < myChilds.length;  i++) {
      if (myChilds[i] instanceof XSElement) {
        XSElement element = (XSElement) myChilds[i];
        XsQName qName = element.getSubstitutionGroupName();
        if (qName != null) {
          SubstitutionGroup group = (SubstitutionGroup) substitutionGroups.get(qName);
          if (group == null) {
            XSElement head = pSchema.getElement(qName);
            if (head == null) {
              throw new LocSAXException("The substituted element " + qName + " is missing in the schema.",
                                         element.getLocator());
            }
            if (head.isBlockedForSubstitution()) {
              throw new LocSAXException("The substituted element " + qName + " is blocked for substitution.",
                                         element.getLocator());
            }
            group = new SubstitutionGroup(head);
            if (!head.isAbstract()) {
              group.addMember(head);
            }
            substitutionGroups.put(qName, group);
          }
          group.addMember(element);
        }
      }
    }

    // For any substitution group: Build an implicit choice group, which
    // may be used to replace the substitution groups head, if required.
    for (Iterator iter = substitutionGroups.values().iterator();  iter.hasNext()) {
      SubstitutionGroup group = (SubstitutionGroup) iter.next();
      XSElementImpl head = (XSElementImpl) group.getHead();
      XsObject object = head.getXsObject();
      XsESchema syntaxSchema = object.getXsESchema();

      // Find a name for the group
      String namespace = syntaxSchema.getTargetNamespace().toString();
      String localName = head.getName().getLocalName() + "Group";
      XsQName suggestion = new XsQName(namespace, localName);
      if (pSchema.getGroup(suggestion) != null) {
        for (int i = 0;  ;  i++) {
          suggestion = new XsQName(namespace, localName + i);
          if (pSchema.getGroup(suggestion) == null) {
            break;
          }
        }
      }

      XsTNamedGroup namedGroup = object.getObjectFactory().newXsTNamedGroup(syntaxSchema);
      namedGroup.setName(new XsNCName(suggestion.getLocalName()));
      XsTSimpleExplicitGroup choice = namedGroup.createChoice();
      XSElement[] members = group.getMembers();
      for (int j = 0;  j < members.length;  j++) {
        XSElement member = members[j];
        XsTLocalElement memberElement = choice.createElement();
        memberElement.setRef(member.getName());
      }

      XSGroupImpl xsGroup = (XSGroupImpl) getSchema().getXSObjectFactory().newXSGroup(pSchema, namedGroup);
      pSchema.add(xsGroup);
      head.setSubstitutionGroup(xsGroup);
    }
  }

  /** <p>This is the logical parsers frontend for parsing a stream
   * of SAX events.</p>
   */
  public XSContentHandler getXSContentHandler() throws SAXException {
    return new XSContentHandlerImpl(this);
  }

  /** <p>This is the logical parsers frontend for parsing a DOM node.</p>
   */
  public XSSchema parse(Node pNode) throws SAXException {
    XSContentHandler handler = getXSContentHandler();
    DOMSerializer ds = new DOMSerializer();
    ds.serialize(pNode, handler);
    return handler.getXSSchema();
  }

  /** <p>This is the logical parsers frontend for parsing the given
   * {@link InputSource}. If the parsed schema includes or imports other
   * schemas, they are also parsed and added to the parsers object
   * tree.</p>
   * @see #getXSContentHandler()
   */
  public XSSchema parse(InputSource pSource)
      throws ParserConfigurationException, SAXException, IOException {
    XSContentHandler contentHandler = getXSContentHandler();
    XSContext data = getData();
    XMLReader xr = data.getXsObjectFactory().newXMLReader(isValidating());
    xr.setContentHandler(contentHandler);
    xr.parse(pSource);
    return getSchema();
  }

  protected void clearSyntaxSchemas() {
    syntaxSchemas.clear();
    syntaxSchemaArray = null;
  }

  protected void addSyntaxSchema(XsESchema pSyntaxSchema) {
    syntaxSchemas.add(pSyntaxSchema);
    syntaxSchemaArray = null;
  }

  protected void removeSyntaxSchema() {
    syntaxSchemas.remove(syntaxSchemas.size()-1);
    syntaxSchemaArray = null;
  }

  /** <p>Provides context information to the schema which is currently being parsed.
   * The schema with index 0 is the outermost schema, on which the parser is actually
   * invoked.</p>
   */
  public XsESchema[] getSyntaxSchemas() {
    if (syntaxSchemaArray == null) {
      syntaxSchemaArray = (XsESchema[]) syntaxSchemas.toArray(new XsESchema[syntaxSchemas.size()]);
    }
    return syntaxSchemaArray;
  }

  /** <p>Returns the syntax schema, which is currently being parsed.</p>
   */
  public XsESchema getCurrentSyntaxSchema() {
    if (syntaxSchemaArray == null  ||  syntaxSchemaArray.length == 0) {
      return null;
    } else {
      return syntaxSchemaArray[syntaxSchemaArray.length-1];
    }
  }
}
TOP

Related Classes of org.apache.ws.jaxme.xs.impl.XSLogicalParser$SubstitutionGroup

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.