310 lines
11 KiB
Java
310 lines
11 KiB
Java
/*
|
|
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.xml.internal.xsom.impl;
|
|
|
|
import com.sun.xml.internal.xsom.ForeignAttributes;
|
|
import com.sun.xml.internal.xsom.SCD;
|
|
import com.sun.xml.internal.xsom.XSAnnotation;
|
|
import com.sun.xml.internal.xsom.XSAttGroupDecl;
|
|
import com.sun.xml.internal.xsom.XSAttributeDecl;
|
|
import com.sun.xml.internal.xsom.XSComplexType;
|
|
import com.sun.xml.internal.xsom.XSComponent;
|
|
import com.sun.xml.internal.xsom.XSElementDecl;
|
|
import com.sun.xml.internal.xsom.XSIdentityConstraint;
|
|
import com.sun.xml.internal.xsom.XSModelGroupDecl;
|
|
import com.sun.xml.internal.xsom.XSNotation;
|
|
import com.sun.xml.internal.xsom.XSSchema;
|
|
import com.sun.xml.internal.xsom.XSSimpleType;
|
|
import com.sun.xml.internal.xsom.XSType;
|
|
import com.sun.xml.internal.xsom.parser.SchemaDocument;
|
|
import com.sun.xml.internal.xsom.visitor.XSFunction;
|
|
import com.sun.xml.internal.xsom.visitor.XSVisitor;
|
|
import org.xml.sax.Locator;
|
|
|
|
import javax.xml.namespace.NamespaceContext;
|
|
import java.text.ParseException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
public class SchemaImpl implements XSSchema
|
|
{
|
|
public SchemaImpl(SchemaSetImpl _parent, Locator loc, String tns) {
|
|
if (tns == null)
|
|
// the empty string must be used.
|
|
throw new IllegalArgumentException();
|
|
this.targetNamespace = tns;
|
|
this.parent = _parent;
|
|
this.locator = loc;
|
|
}
|
|
|
|
public SchemaDocument getSourceDocument() {
|
|
return null;
|
|
}
|
|
|
|
public SchemaSetImpl getRoot() {
|
|
return parent;
|
|
}
|
|
|
|
protected final SchemaSetImpl parent;
|
|
|
|
private final String targetNamespace;
|
|
public String getTargetNamespace() {
|
|
return targetNamespace;
|
|
}
|
|
|
|
public XSSchema getOwnerSchema() {
|
|
return this;
|
|
}
|
|
|
|
private XSAnnotation annotation;
|
|
public void setAnnotation(XSAnnotation a) {
|
|
annotation = a;
|
|
}
|
|
public XSAnnotation getAnnotation() {
|
|
return annotation;
|
|
}
|
|
|
|
public XSAnnotation getAnnotation(boolean createIfNotExist) {
|
|
if(createIfNotExist && annotation==null)
|
|
annotation = new AnnotationImpl();
|
|
return annotation;
|
|
}
|
|
|
|
// it's difficult to determine the source location for the schema
|
|
// component as one schema can be defined across multiple files.
|
|
// so this locator might not correctly reflect all the locations
|
|
// where the schema is defined.
|
|
// but partial information would be better than nothing.
|
|
|
|
private final Locator locator;
|
|
public Locator getLocator() {
|
|
return locator;
|
|
}
|
|
|
|
|
|
private final Map<String,XSAttributeDecl> atts = new HashMap<String,XSAttributeDecl>();
|
|
private final Map<String,XSAttributeDecl> attsView = Collections.unmodifiableMap(atts);
|
|
public void addAttributeDecl(XSAttributeDecl newDecl) {
|
|
atts.put(newDecl.getName(), newDecl);
|
|
}
|
|
public Map<String,XSAttributeDecl> getAttributeDecls() {
|
|
return attsView;
|
|
}
|
|
public XSAttributeDecl getAttributeDecl(String name) {
|
|
return atts.get(name);
|
|
}
|
|
public Iterator<XSAttributeDecl> iterateAttributeDecls() {
|
|
return atts.values().iterator();
|
|
}
|
|
|
|
private final Map<String,XSElementDecl> elems = new HashMap<String,XSElementDecl>();
|
|
private final Map<String,XSElementDecl> elemsView = Collections.unmodifiableMap(elems);
|
|
public void addElementDecl(XSElementDecl newDecl) {
|
|
elems.put(newDecl.getName(), newDecl);
|
|
}
|
|
public Map<String,XSElementDecl> getElementDecls() {
|
|
return elemsView;
|
|
}
|
|
public XSElementDecl getElementDecl(String name) {
|
|
return elems.get(name);
|
|
}
|
|
public Iterator<XSElementDecl> iterateElementDecls() {
|
|
return elems.values().iterator();
|
|
}
|
|
|
|
private final Map<String,XSAttGroupDecl> attGroups = new HashMap<String,XSAttGroupDecl>();
|
|
private final Map<String,XSAttGroupDecl> attGroupsView = Collections.unmodifiableMap(attGroups);
|
|
public void addAttGroupDecl(XSAttGroupDecl newDecl, boolean overwrite) {
|
|
if(overwrite || !attGroups.containsKey(newDecl.getName()))
|
|
attGroups.put(newDecl.getName(), newDecl);
|
|
}
|
|
public Map<String,XSAttGroupDecl> getAttGroupDecls() {
|
|
return attGroupsView;
|
|
}
|
|
public XSAttGroupDecl getAttGroupDecl(String name) {
|
|
return attGroups.get(name);
|
|
}
|
|
public Iterator<XSAttGroupDecl> iterateAttGroupDecls() {
|
|
return attGroups.values().iterator();
|
|
}
|
|
|
|
|
|
private final Map<String,XSNotation> notations = new HashMap<String,XSNotation>();
|
|
private final Map<String,XSNotation> notationsView = Collections.unmodifiableMap(notations);
|
|
public void addNotation( XSNotation newDecl ) {
|
|
notations.put( newDecl.getName(), newDecl );
|
|
}
|
|
public Map<String,XSNotation> getNotations() {
|
|
return notationsView;
|
|
}
|
|
public XSNotation getNotation( String name ) {
|
|
return notations.get(name);
|
|
}
|
|
public Iterator<XSNotation> iterateNotations() {
|
|
return notations.values().iterator();
|
|
}
|
|
|
|
private final Map<String,XSModelGroupDecl> modelGroups = new HashMap<String,XSModelGroupDecl>();
|
|
private final Map<String,XSModelGroupDecl> modelGroupsView = Collections.unmodifiableMap(modelGroups);
|
|
public void addModelGroupDecl(XSModelGroupDecl newDecl, boolean overwrite) {
|
|
if(overwrite || !modelGroups.containsKey(newDecl.getName()))
|
|
modelGroups.put(newDecl.getName(), newDecl);
|
|
}
|
|
public Map<String,XSModelGroupDecl> getModelGroupDecls() {
|
|
return modelGroupsView;
|
|
}
|
|
public XSModelGroupDecl getModelGroupDecl(String name) {
|
|
return modelGroups.get(name);
|
|
}
|
|
public Iterator<XSModelGroupDecl> iterateModelGroupDecls() {
|
|
return modelGroups.values().iterator();
|
|
}
|
|
|
|
|
|
private final Map<String,XSIdentityConstraint> idConstraints = new HashMap<String,XSIdentityConstraint>();
|
|
private final Map<String,XSIdentityConstraint> idConstraintsView = Collections.unmodifiableMap(idConstraints);
|
|
|
|
protected void addIdentityConstraint(IdentityConstraintImpl c) {
|
|
idConstraints.put(c.getName(),c);
|
|
}
|
|
|
|
public Map<String, XSIdentityConstraint> getIdentityConstraints() {
|
|
return idConstraintsView;
|
|
}
|
|
|
|
public XSIdentityConstraint getIdentityConstraint(String localName) {
|
|
return idConstraints.get(localName);
|
|
}
|
|
|
|
private final Map<String,XSType> allTypes = new HashMap<String,XSType>();
|
|
private final Map<String,XSType> allTypesView = Collections.unmodifiableMap(allTypes);
|
|
|
|
private final Map<String,XSSimpleType> simpleTypes = new HashMap<String,XSSimpleType>();
|
|
private final Map<String,XSSimpleType> simpleTypesView = Collections.unmodifiableMap(simpleTypes);
|
|
public void addSimpleType(XSSimpleType newDecl, boolean overwrite) {
|
|
if(overwrite || !simpleTypes.containsKey(newDecl.getName())) {
|
|
simpleTypes.put(newDecl.getName(), newDecl);
|
|
allTypes.put(newDecl.getName(), newDecl);
|
|
}
|
|
}
|
|
public Map<String,XSSimpleType> getSimpleTypes() {
|
|
return simpleTypesView;
|
|
}
|
|
public XSSimpleType getSimpleType(String name) {
|
|
return simpleTypes.get(name);
|
|
}
|
|
public Iterator<XSSimpleType> iterateSimpleTypes() {
|
|
return simpleTypes.values().iterator();
|
|
}
|
|
|
|
private final Map<String,XSComplexType> complexTypes = new HashMap<String,XSComplexType>();
|
|
private final Map<String,XSComplexType> complexTypesView = Collections.unmodifiableMap(complexTypes);
|
|
public void addComplexType(XSComplexType newDecl, boolean overwrite) {
|
|
if(overwrite || !complexTypes.containsKey(newDecl.getName())) {
|
|
complexTypes.put(newDecl.getName(), newDecl);
|
|
allTypes.put(newDecl.getName(), newDecl);
|
|
}
|
|
}
|
|
public Map<String,XSComplexType> getComplexTypes() {
|
|
return complexTypesView;
|
|
}
|
|
public XSComplexType getComplexType(String name) {
|
|
return complexTypes.get(name);
|
|
}
|
|
public Iterator<XSComplexType> iterateComplexTypes() {
|
|
return complexTypes.values().iterator();
|
|
}
|
|
|
|
public Map<String,XSType> getTypes() {
|
|
return allTypesView;
|
|
}
|
|
public XSType getType(String name) {
|
|
return allTypes.get(name);
|
|
}
|
|
public Iterator<XSType> iterateTypes() {
|
|
return allTypes.values().iterator();
|
|
}
|
|
|
|
public void visit(XSVisitor visitor) {
|
|
visitor.schema(this);
|
|
}
|
|
|
|
public Object apply(XSFunction function) {
|
|
return function.schema(this);
|
|
}
|
|
|
|
/**
|
|
* Lazily created list of {@link ForeignAttributesImpl}s.
|
|
*/
|
|
private List<ForeignAttributes> foreignAttributes = null;
|
|
private List<ForeignAttributes> readOnlyForeignAttributes = null;
|
|
|
|
public void addForeignAttributes(ForeignAttributesImpl fa) {
|
|
if(foreignAttributes==null)
|
|
foreignAttributes = new ArrayList<ForeignAttributes>();
|
|
foreignAttributes.add(fa);
|
|
}
|
|
|
|
public List<ForeignAttributes> getForeignAttributes() {
|
|
if(readOnlyForeignAttributes==null) {
|
|
if(foreignAttributes==null)
|
|
readOnlyForeignAttributes = Collections.EMPTY_LIST;
|
|
else
|
|
readOnlyForeignAttributes = Collections.unmodifiableList(foreignAttributes);
|
|
}
|
|
return readOnlyForeignAttributes;
|
|
}
|
|
|
|
public String getForeignAttribute(String nsUri, String localName) {
|
|
for( ForeignAttributes fa : getForeignAttributes() ) {
|
|
String v = fa.getValue(nsUri,localName);
|
|
if(v!=null) return v;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Collection<XSComponent> select(String scd, NamespaceContext nsContext) {
|
|
try {
|
|
return SCD.create(scd,nsContext).select(this);
|
|
} catch (ParseException e) {
|
|
throw new IllegalArgumentException(e);
|
|
}
|
|
}
|
|
|
|
public XSComponent selectSingle(String scd, NamespaceContext nsContext) {
|
|
try {
|
|
return SCD.create(scd,nsContext).selectSingle(this);
|
|
} catch (ParseException e) {
|
|
throw new IllegalArgumentException(e);
|
|
}
|
|
}
|
|
}
|