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 

This is page for exploring of selected project.

Current project is "".
If you'd like to explore another project push and select another project in projects tree.

Project is a set of files. So to start select one in "Projects" tab:

Now you could navigate to declarations just clicking on identifiers in code:

Use Ctrl <- and Ctrl -> to go "Back" and "Forward" on navigation history.

Also you could find "class view" for opened file in "Navigator" tab: