Usages:

Right click on identifier in code to find usages!

 
1   /*
2    * The contents of this file are subject to the terms
3    * of the Common Development and Distribution License
4    * (the "License").  You may not use this file except
5    * in compliance with the License.
6    * 
7    * You can obtain a copy of the license at
8    * https://jwsdp.dev.java.net/CDDLv1.0.html
9    * See the License for the specific language governing
10   * permissions and limitations under the License.
11   * 
12   * When distributing Covered Code, include this CDDL
13   * HEADER in each file and include the License file at
14   * https://jwsdp.dev.java.net/CDDLv1.0.html  If applicable,
15   * add the following below this CDDL HEADER, with the
16   * fields enclosed by brackets "[]" replaced with your
17   * own identifying information: Portions Copyright [yyyy]
18   * [name of copyright owner]
19   */

20  package com.sun.xml.xsom.impl;
21  
22  import com.sun.xml.xsom.XSAttGroupDecl;
23  import com.sun.xml.xsom.XSAttributeDecl;
24  import com.sun.xml.xsom.XSAttributeUse;
25  import com.sun.xml.xsom.XSComplexType;
26  import com.sun.xml.xsom.XSContentType;
27  import com.sun.xml.xsom.XSElementDecl;
28  import com.sun.xml.xsom.XSFacet;
29  import com.sun.xml.xsom.XSIdentityConstraint;
30  import com.sun.xml.xsom.XSListSimpleType;
31  import com.sun.xml.xsom.XSModelGroup;
32  import com.sun.xml.xsom.XSModelGroupDecl;
33  import com.sun.xml.xsom.XSParticle;
34  import com.sun.xml.xsom.XSRestrictionSimpleType;
35  import com.sun.xml.xsom.XSSchema;
36  import com.sun.xml.xsom.XSSchemaSet;
37  import com.sun.xml.xsom.XSSimpleType;
38  import com.sun.xml.xsom.XSType;
39  import com.sun.xml.xsom.XSUnionSimpleType;
40  import com.sun.xml.xsom.XSVariety;
41  import com.sun.xml.xsom.XSWildcard;
42  import com.sun.xml.xsom.visitor.XSContentTypeFunction;
43  import com.sun.xml.xsom.visitor.XSContentTypeVisitor;
44  import com.sun.xml.xsom.visitor.XSFunction;
45  import com.sun.xml.xsom.visitor.XSSimpleTypeFunction;
46  import com.sun.xml.xsom.visitor.XSSimpleTypeVisitor;
47  import com.sun.xml.xsom.visitor.XSVisitor;
48  import org.xml.sax.Locator;
49  
50  import java.util.Collection;
51  import java.util.Collections;
52  import java.util.HashMap;
53  import java.util.Iterator;
54  import java.util.List;
55  import java.util.Map;
56  import java.util.NoSuchElementException;
57  import java.util.Vector;
58  
59  public class SchemaSetImpl implements XSSchemaSet
60  {
61      private final Map<String,XSSchemaschemas = new HashMap<String,XSSchema>();
62      private final Vector<XSSchemaschemas2 = new Vector<XSSchema>();
63      private final List<XSSchemareadonlySchemaList = Collections.unmodifiableList(schemas2);
64  
65      /**
66       * Gets a reference to the existing schema or creates a new one
67       * if none exists yet.
68       */

69      public SchemaImpl createSchema(String targetNamespaceLocator location) {
70          SchemaImpl obj = (SchemaImpl)schemas.get(targetNamespace);
71          if (obj == null) {
72              obj = new SchemaImpl(thislocationtargetNamespace);
73              schemas.put(targetNamespaceobj);
74              schemas2.add(obj);
75          }
76          return obj;
77      }
78  
79      public int getSchemaSize() {
80          return schemas.size();
81      }
82      public XSSchema getSchema(String targetNamespace) {
83          return schemas.get(targetNamespace);
84      }
85      public XSSchema getSchema(int idx) {
86          return schemas2.get(idx);
87      }
88      public Iterator<XSSchemaiterateSchema() {
89          return schemas2.iterator();
90      }
91  
92      public final Collection<XSSchemagetSchemas() {
93          return readonlySchemaList;
94      }
95  
96      public XSType getType(String nsString localName) {
97          XSSchema schema = getSchema(ns);
98          if(schema==null)    return null;
99  
100         return schema.getType(localName);
101     }
102 
103     public XSSimpleType getSimpleTypeString nsString localName ) {
104         XSSchema schema = getSchema(ns);
105         if(schema==null)    return null;
106         
107         return schema.getSimpleType(localName);
108     }
109     
110     public XSElementDecl getElementDeclString nsString localName ) {
111         XSSchema schema = getSchema(ns);
112         if(schema==null)    return null;
113         
114         return schema.getElementDecl(localName);
115     }
116     
117     public XSAttributeDecl getAttributeDeclString nsString localName ) {
118         XSSchema schema = getSchema(ns);
119         if(schema==null)    return null;
120         
121         return schema.getAttributeDecl(localName);
122     }
123     
124     public XSModelGroupDecl getModelGroupDeclString nsString localName ) {
125         XSSchema schema = getSchema(ns);
126         if(schema==null)    return null;
127         
128         return schema.getModelGroupDecl(localName);
129     }
130     
131     public XSAttGroupDecl getAttGroupDeclString nsString localName ) {
132         XSSchema schema = getSchema(ns);
133         if(schema==null)    return null;
134         
135         return schema.getAttGroupDecl(localName);
136     }
137     
138     public XSComplexType getComplexTypeString nsString localName ) {
139         XSSchema schema = getSchema(ns);
140         if(schema==null)    return null;
141         
142         return schema.getComplexType(localName);
143     }
144 
145     public XSIdentityConstraint getIdentityConstraint(String nsString localName) {
146         XSSchema schema = getSchema(ns);
147         if(schema==null)    return null;
148 
149         return schema.getIdentityConstraint(localName);
150     }
151 
152     private abstract class MultiSchemaIterator<Timplements Iterator<T> {
153         private Iterator<XSSchemasitr = iterateSchema();
154         private Iterator<Tcitr = null;
155         /** The object to be returned from the next method. */
156         private T next;
157         
158         public void remove() { throw new UnsupportedOperationException(); }
159         public boolean hasNext() {
160             getNext();
161             return next!=null;
162         }
163         public T next() {
164             getNext();
165             T r = next;
166             next = null;
167             return r;
168         }
169         private void getNext() {
170             if(next!=null)  return;
171             
172             if(citr!=null && citr.hasNext()) {
173                 next = citr.next();
174                 return;
175             }
176             // citr is empty
177 
            if(sitr.hasNext()) {
178                 citr = nextIterator(sitr.next());
179                 getNext();
180             }
181             // else
182 
            //      no more object
183 
        }
184         
185         protected abstract Iterator<TnextIteratorXSSchema s );
186     }
187     
188     public Iterator iterateElementDecls() {
189         return new MultiSchemaIterator() {
190             protected Iterator nextIteratorXSSchema xs ) {
191                 return xs.iterateElementDecls();
192             }
193         };
194     }
195 
196     public Iterator iterateTypes() {
197         return new MultiSchemaIterator() {
198             protected Iterator nextIteratorXSSchema xs ) {
199                 return xs.iterateTypes();
200             }
201         };
202     }
203 
204     public Iterator iterateAttributeDecls() {
205         return new MultiSchemaIterator() {
206             protected Iterator nextIteratorXSSchema xs ) {
207                 return xs.iterateAttributeDecls();
208             }
209         };
210     }
211     public Iterator iterateAttGroupDecls() {
212         return new MultiSchemaIterator() {
213             protected Iterator nextIteratorXSSchema xs ) {
214                 return xs.iterateAttGroupDecls();
215             }
216         };
217     }
218     public Iterator iterateModelGroupDecls() {
219         return new MultiSchemaIterator() {
220             protected Iterator nextIteratorXSSchema xs ) {
221                 return xs.iterateModelGroupDecls();
222             }
223         };
224     }
225     public Iterator iterateSimpleTypes() {
226         return new MultiSchemaIterator() {
227             protected Iterator nextIteratorXSSchema xs ) {
228                 return xs.iterateSimpleTypes();
229             }
230         };
231     }
232     public Iterator iterateComplexTypes() {
233         return new MultiSchemaIterator() {
234             protected Iterator nextIteratorXSSchema xs ) {
235                 return xs.iterateComplexTypes();
236             }
237         };
238     }
239     public Iterator iterateNotations() {
240         return new MultiSchemaIterator() {
241             protected Iterator nextIteratorXSSchema xs ) {
242                 return xs.iterateNotations();
243             }
244         };
245     }
246 
247     public Iterator<XSIdentityConstraintiterateIdentityConstraints() {
248         return new MultiSchemaIterator() {
249             protected Iterator nextIteratorXSSchema xs ) {
250                 return xs.getIdentityConstraints().values().iterator();
251             }
252         };
253     }
254 
255 
256     public final EmptyImpl empty = new EmptyImpl();
257     public XSContentType getEmpty() { return empty; }
258     
259     public XSSimpleType getAnySimpleType() { return anySimpleType; }
260     public final AnySimpleType anySimpleType = new AnySimpleType();
261     private class AnySimpleType extends DeclarationImpl
262         implements XSRestrictionSimpleTypeRef.SimpleType {
263         
264         AnySimpleType() {
265             super(
266                 createSchema("http://www.w3.org/2001/XMLSchema",null),
267                 null,null,null,"http://www.w3.org/2001/XMLSchema","anySimpleType",false);
268         }
269         public XSSimpleType asSimpleType() { return this; }
270         public XSComplexType asComplexType() { return null; }
271 
272         public boolean isDerivedFrom(XSType t) {
273             return t==this || t==anyType;
274         }
275 
276         public boolean isSimpleType()       { return true; }
277         public boolean isComplexType()      { return false; }
278         public XSContentType asEmpty() { return null; }
279         public XSParticle asParticle() { return null; }
280         public XSType getBaseType() { return anyType; }
281         public XSSimpleType getSimpleBaseType() { return null; }
282         public int getDerivationMethod() { return RESTRICTION; }
283         public Iterator iterateDeclaredFacets() { return emptyIterator; }
284         public Collection<? extends XSFacetgetDeclaredFacets() { return Collections.EMPTY_LIST; }
285         public void visitXSSimpleTypeVisitor visitor ) {visitor.restrictionSimpleType(this); }
286         public void visitXSContentTypeVisitor visitor ) {visitor.simpleType(this); }
287         public void visitXSVisitor visitor ) {visitor.simpleType(this); }
288         public <TT applyXSSimpleTypeFunction<Tf ) {return f.restrictionSimpleType(this); }
289         public <TT applyXSContentTypeFunction<Tf ) { return f.simpleType(this); }
290         public <TT applyXSFunction<Tf ) { return f.simpleType(this); }
291         public XSVariety getVariety() { return XSVariety.ATOMIC; }
292         public XSFacet getFacet(String name) { return null; }
293         public XSFacet getDeclaredFacet(String name) { return null; }
294         public List<XSFacetgetDeclaredFacets(String name) { return Collections.EMPTY_LIST; }
295 
296         public boolean isRestriction() { return true; }
297         public boolean isList() { return false; }
298         public boolean isUnion() { return false; }
299         public boolean isFinal(XSVariety v) { return false; }
300         public XSRestrictionSimpleType asRestriction() { return this; }
301         public XSListSimpleType asList() { return null; }
302         public XSUnionSimpleType asUnion() { return null; }
303         public XSSimpleType getType() { return this; } // Ref.SimpleType implementation
304 
        public XSSimpleType getRedefinedBy() { return null; }
305         public int getRedefinedCount() { return 0; }
306 
307         public XSType[] listSubstitutables() {
308             return Util.listSubstitutables(this);
309         }
310     };
311 
312     public XSComplexType getAnyType() { return anyType; }
313     public final AnyType anyType = new AnyType();
314     private class AnyType extends DeclarationImpl implements XSComplexTypeRef.Type {
315         AnyType() {
316             super(
317                 createSchema("http://www.w3.org/2001/XMLSchema",null),
318                 null,null,
319                 null,"http://www.w3.org/2001/XMLSchema","anyType",false);
320         }
321         public boolean isAbstract() { return false; }
322         public XSWildcard getAttributeWildcard() { return anyWildcard; }
323         public XSAttributeUse getAttributeUseString nsURIString localName ) { return null; }
324         public Iterator iterateAttributeUses() { return emptyIterator; }
325         public XSAttributeUse getDeclaredAttributeUseString nsURIString localName ) { return null; }
326         public Iterator iterateDeclaredAttributeUses() { return emptyIterator; }
327         public Iterator iterateAttGroups() { return emptyIterator; }
328         public Collection<XSAttributeUsegetAttributeUses() { return Collections.EMPTY_LIST; }
329         public Collection<? extends XSAttributeUsegetDeclaredAttributeUses() { return Collections.EMPTY_LIST; }
330         public Collection<? extends XSAttGroupDeclgetAttGroups() { return Collections.EMPTY_LIST; }
331         public boolean isFinalint i ) { return false; }
332         public boolean isSubstitutionProhibitedint i ) { return false; }
333         public boolean isMixed() { return true; }
334         public XSContentType getContentType() { return contentType; }
335         public XSContentType getExplicitContent() { return null; }
336         public XSType getBaseType() { return this; }
337         public XSSimpleType asSimpleType() { return null; }
338         public XSComplexType asComplexType() { return this; }
339 
340         public boolean isDerivedFrom(XSType t) {
341             return t==this;
342         }
343 
344         public boolean isSimpleType()       { return false; }
345         public boolean isComplexType()      { return true; }
346         public XSContentType asEmpty() { return null; }
347         public int getDerivationMethod() { return XSType.RESTRICTION; }
348         
349         public XSElementDecl getScope() { return null; }
350         public void visitXSVisitor visitor ) { visitor.complexType(this); }
351         public <TT applyXSFunction<Tf ) { return f.complexType(this); }
352         
353         public XSType getType() { return this; } // Ref.Type implementation
354 

355         public XSComplexType getRedefinedBy() { return null; }
356         public int getRedefinedCount() { return 0; }
357 
358         public XSType[] listSubstitutables() {
359             return Util.listSubstitutables(this);
360         }
361         
362         private final WildcardImpl anyWildcard = new WildcardImpl.Any(null,null,null,null,XSWildcard.SKIP);
363         private final XSContentType contentType = new ParticleImplnullnull,
364                 new ModelGroupImpl(nullnullnullnull,XSModelGroup.SEQUENCEnew ParticleImpl[]{
365                     new ParticleImplnullnull,
366                         anyWildcardnull,
367                         XSParticle.UNBOUNDED, 0 )
368                 })
369                 ,null,1,1);
370     };
371     
372     private static final Iterator emptyIterator = new Iterator() {
373         public boolean hasNext() { return false; }
374         public Object next() { throw new NoSuchElementException(); }
375         public void remove() { throw new UnsupportedOperationException(); }
376     };
377     
378 }
379 
380