EnumeratedTypeSet


1   /*******************************************************************************
2    * Copyright (c) 2000, 2006 IBM Corporation and others.
3    * All rights reserved. This program and the accompanying materials
4    * are made available under the terms of the Eclipse Public License v1.0
5    * which accompanies this distribution, and is available at
6    * http://www.eclipse.org/legal/epl-v10.html
7    *
8    * Contributors:
9    *   Robert M. Fuhrer (rfuhrer@watson.ibm.com), IBM Corporation - initial API and implementation
10   *******************************************************************************/
11  package org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets;
12  
13  import java.util.Iterator  ;
14  import java.util.LinkedHashSet  ;
15  import java.util.Set  ;
16  
17  import org.eclipse.core.runtime.Assert;
18  
19  import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.ArrayType;
20  import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType;
21  import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TTypes;
22  
23  /**
24   * A type-safe wrapper for Set<TType> that also adds TType-specific
25   * functionality, e.g. subTypes() and superTypes().
26   */
27  public class EnumeratedTypeSet extends TypeSet {
28      static private int sCount= 0;
29  
30      static public int getCount() {
31          return sCount;
32      }
33  
34      static public void resetCount() {
35          sCount= 0;
36      }
37  
38      /**
39       * Set containing the TTypes in this EnumeratedTypeSet.
40       */
41      Set  /*<TType>*/ fMembers= new LinkedHashSet  ();
42  
43      /**
44       * Constructs a new EnumeratedTypeSet with the members of Set s in it.
45       * All elements of s must be TTypes.
46       */
47      public EnumeratedTypeSet(Iterator   types, TypeSetEnvironment typeSetEnvironment) {
48          super(typeSetEnvironment);
49          while (types.hasNext()) {
50              fMembers.add(types.next());
51          }
52          sCount++;
53      }
54  
55      /**
56       * Constructs an empty EnumeratedTypeSet.
57       */
58      public EnumeratedTypeSet(TypeSetEnvironment typeSetEnvironment) {
59          super(typeSetEnvironment);
60          sCount++;
61      }
62  
63      /**
64       * Constructs a new EnumeratedTypeSet with the given single TType in it.
65       */
66      public EnumeratedTypeSet(TType t, TypeSetEnvironment typeSetEnvironment) {
67          super(typeSetEnvironment);
68          Assert.isNotNull(t);
69          fMembers.add(t);
70          sCount++;
71      }
72  
73      /**
74       * @return <code>true</code> iff this set represents the universe of TTypes
75       */
76      public boolean isUniverse() {
77          return false;
78      }
79  
80      public boolean equals(Object   o) {
81          if (this == o) return true;
82          if (o instanceof EnumeratedTypeSet) {
83              EnumeratedTypeSet other= (EnumeratedTypeSet) o;
84  
85              return fMembers.equals(other.fMembers);
86          } else if (o instanceof SingletonTypeSet) {
87              SingletonTypeSet other= (SingletonTypeSet) o;
88  
89              return (fMembers.size() == 1) && fMembers.contains(other.anyMember());
90          } else if (o instanceof TypeSet) {
91              TypeSet other= (TypeSet) o;
92  
93              for(Iterator   otherIter= other.iterator(); otherIter.hasNext(); ) {
94                  if (!fMembers.contains(otherIter.next()))
95                      return false;
96              }
97              for(Iterator   myIter= fMembers.iterator(); myIter.hasNext(); ) {
98                  if (!other.contains((TType) myIter.next()))
99                      return false;
100             }
101             return true;
102         } else
103             return false;
104     }
105 
106     public int hashCode() {
107         return 37 + fMembers.hashCode();
108     }
109 
110     /**
111      * Computes and returns a <em>new</em> EnumeratedTypeSet representing the intersection of the
112      * receiver with s2. Does not modify the receiver.
113      * @param s2
114      */
115     protected TypeSet specialCasesIntersectedWith(TypeSet s2) {
116         if (s2 instanceof EnumeratedTypeSet) {
117             EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
118 
119             result.addAll(this); // copy first since retainAll() modifies in-place
120             result.retainAll(s2);
121             if (result.size() > 0)
122                 return result;
123             else
124                 return getTypeSetEnvironment().getEmptyTypeSet();
125         }
126         return null;
127     }
128 
129     /**
130      * Modifies this EnumeratedTypeSet to represent the intersection of the receiver with s2.
131      * @param s2
132      */
133     public void intersectWith(TypeSet s2) {
134         if (isUniverse()) {
135             if (s2.isUniverse())
136                 return;
137             // More than an optimization: the universe never contains array types, so
138             // if s2 has array types, the following will retain them, as it should.
139             EnumeratedTypeSet ets2= (EnumeratedTypeSet) s2;
140             fMembers= new LinkedHashSet  ();
141             fMembers.addAll(ets2.fMembers);
142         } else
143             retainAll(s2);
144     }
145 
146     /**
147      * @return a new TypeSet representing the set of all sub-types of the
148      * types in the receiver
149      */
150     public TypeSet subTypes() {
151         if (isUniverse())
152             return makeClone(); // subtypes(universe) = universe
153 
154         if (fMembers.contains(getJavaLangObject()))
155             return getTypeSetEnvironment().getUniverseTypeSet();
156 
157         return getTypeSetEnvironment().createSubTypesSet(this);
158     }
159 
160     public static EnumeratedTypeSet makeArrayTypesForElements(Iterator  /*<TType>*/ elemTypes, TypeSetEnvironment typeSetEnvironment) {
161         EnumeratedTypeSet result= new EnumeratedTypeSet(typeSetEnvironment);
162 
163         while (elemTypes.hasNext()) {
164             TType t= (TType) elemTypes.next();
165             result.add(TTypes.createArrayType(t, 1));
166         }
167 //      result.initComplete();
168         return result;
169     }
170 
171     /**
172      * @return a new TypeSet representing the set of all super-types of the
173      * types in the receiver
174      */
175     public TypeSet superTypes() {
176         if (isUniverse())
177             return makeClone(); // The supertypes of the universe is the universe
178 
179         return getTypeSetEnvironment().createSuperTypesSet(this);
180     }
181 
182     public TypeSet makeClone() {
183         EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
184 
185         result.fMembers.addAll(fMembers);
186         result.initComplete();
187         return result;
188     }
189 
190     /* (non-Javadoc)
191      * @see java.util.Set#size()
192      */
193     public int size() {
194         return fMembers.size();
195     }
196 
197     /* (non-Javadoc)
198      * @see java.util.Set#clear()
199      */
200     public void clear() {
201         if (isUniverse())
202             fMembers= new LinkedHashSet  ();
203         else
204             fMembers.clear();
205     }
206 
207     /* (non-Javadoc)
208      * @see java.util.Set#isEmpty()
209      */
210     public boolean isEmpty() {
211         return fMembers.isEmpty();
212     }
213 
214     /* (non-Javadoc)
215      * @see java.util.Set#toArray()
216      */
217     public TType[] toArray() {
218         return (TType[]) fMembers.toArray(new TType[fMembers.size()]);
219     }
220 
221     /* (non-Javadoc)
222      * @see java.util.Set#add(java.lang.Object)
223      */
224     public boolean add(TType t) {
225         // Doesn't make sense to do here what other methods do (copy-and-modify)
226         Assert.isTrue(!isUniverse(), "Someone's trying to expand the universe!"); //$NON-NLS-1$
227         return fMembers.add(t);
228     }
229 
230     /* (non-Javadoc)
231      * @see java.util.Set#contains(java.lang.Object)
232      */
233     public boolean contains(TType t) {
234         if (isUniverse())
235             return true;
236         return fMembers.contains(t);
237     }
238 
239     /* (non-Javadoc)
240      * @see java.util.Set#remove(java.lang.Object)
241      */
242     public boolean remove(TType t) {
243         if (isUniverse())
244             fMembers= cloneSet(fMembers);
245         return fMembers.remove(t);
246     }
247 
248     private Set   cloneSet(Set   members) {
249         Set   result= new LinkedHashSet  ();
250         result.addAll(members);
251         return result;
252     }
253 
254     /* (non-Javadoc)
255      * @see java.util.Set#addAll(java.util.Collection)
256      */
257     public boolean addAll(TypeSet s) {
258         if (s instanceof EnumeratedTypeSet) {
259             EnumeratedTypeSet ets= (EnumeratedTypeSet) s;
260 
261             return fMembers.addAll(ets.fMembers);
262         } else {
263             EnumeratedTypeSet ets= s.enumerate();
264 
265             return fMembers.addAll(ets.fMembers);
266         }
267     }
268 
269     public TypeSet addedTo(TypeSet that) {
270         EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
271 
272         result.addAll(this);
273         result.addAll(that);
274         result.initComplete();
275         return result;
276     }
277 
278     /* (non-Javadoc)
279      * @see java.util.Set#containsAll(java.util.Collection)
280      */
281     public boolean containsAll(TypeSet s) {
282         if (isUniverse())
283             return true;
284         if (s.isUniverse())
285             return false;
286         EnumeratedTypeSet ets= s.enumerate();
287 
288         return fMembers.containsAll(ets.fMembers);
289     }
290 
291     /* (non-Javadoc)
292      * @see java.util.Set#removeAll(java.util.Collection)
293      */
294     public boolean removeAll(EnumeratedTypeSet s) {
295         if (isUniverse())
296             fMembers= cloneSet(fMembers);
297         return fMembers.removeAll(s.fMembers);
298     }
299 
300     /* (non-Javadoc)
301      * @see java.util.Set#retainAll(java.util.Collection)
302      */
303     public boolean retainAll(TypeSet s) {
304         if (s.isUniverse()) return false;
305 
306         EnumeratedTypeSet ets= (EnumeratedTypeSet) s;
307 
308         if (isUniverse()) {
309             fMembers= cloneSet(ets.fMembers);
310             return true;
311         } else
312             return fMembers.retainAll(ets.fMembers);
313     }
314 
315     /* (non-Javadoc)
316      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#isSingleton()
317      */
318     public boolean isSingleton() {
319         return fMembers.size() == 1;
320     }
321 
322     /* (non-Javadoc)
323      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#anyMember()
324      */
325     public TType anyMember() {
326         return (TType) fMembers.iterator().next();
327     }
328 
329     /* (non-Javadoc)
330      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#upperBound()
331      */
332     public TypeSet upperBound() {
333         if (fMembers.size() == 1)
334             return new SingletonTypeSet((TType) fMembers.iterator().next(), getTypeSetEnvironment());
335         if (fMembers.contains(getJavaLangObject()))
336             return new SingletonTypeSet(getJavaLangObject(), getTypeSetEnvironment());
337 
338         EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
339 
340         // Add to result each element of fMembers that has no proper supertype in fMembers
341         result.fMembers.addAll(fMembers);
342         for(Iterator   iter= fMembers.iterator(); iter.hasNext(); ) {
343             TType t= (TType) iter.next();
344 
345             if (t.isArrayType()) {
346                 ArrayType at= (ArrayType) t;
347                 int numDims= at.getDimensions();
348                 for(Iterator   subIter=TTypes.getAllSubTypesIterator(at.getElementType()); subIter.hasNext(); ) {
349                     result.fMembers.remove(TTypes.createArrayType(((TType) subIter.next()), numDims));
350                 }
351             } else {
352                 for (Iterator   iterator= TTypes.getAllSubTypesIterator(t); iterator.hasNext();) {
353                     result.fMembers.remove(iterator.next());                    
354                 }
355             }
356         }
357         result.initComplete();
358         return result;
359     }
360 
361     /* (non-Javadoc)
362      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#lowerBound()
363      */
364     public TypeSet lowerBound() {
365         if (fMembers.size() == 1)
366             return new SingletonTypeSet((TType) fMembers.iterator().next(), getTypeSetEnvironment());
367 
368         EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
369 
370         // Add to result each element of fMembers that has no proper subtype in fMembers
371         result.fMembers.addAll(fMembers);
372 
373         for(Iterator   iter= fMembers.iterator(); iter.hasNext(); ) {
374             TType t= (TType) iter.next();
375 
376             // java.lang.Object is only in the lower bound if fMembers consists
377             // of only java.lang.Object, but that case is handled above.
378             if (t.equals(getJavaLangObject())) {
379                 result.fMembers.remove(t);
380                 continue;
381             }
382 
383             if (t instanceof ArrayType) {
384                 ArrayType at= (ArrayType) t;
385                 int numDims= at.getDimensions();
386                 for(Iterator   superIter=TTypes.getAllSuperTypesIterator(at.getElementType()); superIter.hasNext(); ) {
387                     result.fMembers.remove(TTypes.createArrayType(((TType) superIter.next()), numDims));
388                 }
389             } else {
390                 for (Iterator   iterator= TTypes.getAllSuperTypesIterator(t); iterator.hasNext();) {
391                     result.fMembers.remove(iterator.next());
392                 }
393             }
394         }
395         if (result.size() > 0)
396             return result;
397         else
398             return getTypeSetEnvironment().getEmptyTypeSet();
399     }
400 
401     /* (non-Javadoc)
402      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueLowerBound()
403      */
404     public boolean hasUniqueLowerBound() {
405         return fMembers.size() == 1;
406     }
407 
408     /* (non-Javadoc)
409      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueUpperBound()
410      */
411     public boolean hasUniqueUpperBound() {
412         return fMembers.size() == 1;
413     }
414 
415     /* (non-Javadoc)
416      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueLowerBound()
417      */
418     public TType uniqueLowerBound() {
419         if (fMembers.size() == 1)
420             return (TType) fMembers.iterator().next();
421         return null;
422     }
423 
424     /* (non-Javadoc)
425      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueUpperBound()
426      */
427     public TType uniqueUpperBound() {
428         if (fMembers.size() == 1)
429             return (TType) fMembers.iterator().next();
430         return null;
431     }
432 
433     /* (non-Javadoc)
434      * @see java.util.Set#iterator()
435      */
436     public Iterator   iterator() {
437         return fMembers.iterator();
438     }
439 
440     /* (non-Javadoc)
441      * @see java.util.Set#toArray(java.lang.Object[])
442      */
443     public TType[] toArray(TType[] a) {
444         return (TType[]) fMembers.toArray(a);
445     }
446 
447     /**
448      * Limits the display of set elements to the first sMaxElements.
449      */
450     private static final int sMaxElements= 10; // Integer.MAX_VALUE;
451 
452     /*
453      * (non-Javadoc)
454      * @see java.lang.Object#toString()
455      */
456     public String   toString() {
457         StringBuffer   b= new StringBuffer  ();
458         b.append("{" + fID+ ":"); //$NON-NLS-1$ //$NON-NLS-2$
459         if (isUniverse())
460             b.append(" <universe>"); //$NON-NLS-1$
461         else {
462             int count=0;
463             Iterator   iter;
464             for(iter= iterator(); iter.hasNext() && count < sMaxElements; count++) {
465                 TType type= (TType) iter.next();
466                 b.append(' ')
467                  .append(type.getPrettySignature());
468                 if (iter.hasNext())
469                     b.append(',');
470             }
471             if (iter.hasNext())
472                 b.append(" ..."); //$NON-NLS-1$
473         }
474         b.append(" }"); //$NON-NLS-1$
475         return b.toString();
476     }
477 
478     /* (non-Javadoc)
479      * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#enumerate()
480      */
481     public EnumeratedTypeSet enumerate() {
482         return this; // (EnumeratedTypeSet) makeClone();
483     }
484     
485     public void initComplete() {
486         Assert.isTrue(! fMembers.isEmpty());
487     }
488     
489 }
490
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags