| /* |
| * Copyright (c) 1997, 2014, 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.LinkedHashMap; |
| 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 LinkedHashMap<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 LinkedHashMap<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); |
| } |
| } |
| } |