case-study/jdt-after/core refactoring/org/eclipse/jdt/internal/corext/refactoring/typeconstraints/typesets/EnumeratedTypeSet.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 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 {@code Set<TType>} that also adds {@code TType}-specific
  25  * functionality, e.g. subTypes() and superTypes().
  26  */
  27 public class EnumeratedTypeSet extends TypeSet {
  28         public static 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         public Set<TType> fMembers= new LinkedHashSet<TType>();
  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          * @param types the types
  48          * @param typeSetEnvironment the environment
  49          */
  50         public EnumeratedTypeSet(Iterator<TType> types, TypeSetEnvironment typeSetEnvironment) {
  51                 super(typeSetEnvironment);
  52                 while (types.hasNext()) {
  53                         fMembers.add(types.next());
  54                 }
  55                 sCount++;
  56         }
  57
  58         /**
  59          * Constructs an empty EnumeratedTypeSet.
  60          *
  61          * @param typeSetEnvironment the environment
  62          */
  63         public EnumeratedTypeSet(TypeSetEnvironment typeSetEnvironment) {
  64                 super(typeSetEnvironment);
  65                 sCount++;
  66         }
  67
  68         /**
  69          * Constructs a new EnumeratedTypeSet with the given single TType in it.
  70          *
  71          * @param t the type
  72          * @param typeSetEnvironment the environment
  73          */
  74         public EnumeratedTypeSet(TType t, TypeSetEnvironment typeSetEnvironment) {
  75                 super(typeSetEnvironment);
  76                 t.generated_3769340610219257430(this);
  77         }
  78
  79         /**
  80          * @return <code>true</code> iff this set represents the universe of TTypes
  81          */
  82         @Override
  83         public boolean isUniverse() {
  84                 return false;
  85         }
  86
  87         @Override
  88         public boolean equals(Object o) {
  89                 if (this == o) return true;
  90                 if (o instanceof EnumeratedTypeSet) {
  91                         EnumeratedTypeSet other= (EnumeratedTypeSet) o;
  92
  93                         return fMembers.equals(other.fMembers);
  94                 } else if (o instanceof SingletonTypeSet) {
  95                         SingletonTypeSet other= (SingletonTypeSet) o;
  96
  97                         return (fMembers.size() == 1) && fMembers.contains(other.anyMember());
  98                 } else if (o instanceof TypeSet) {
  99                         TypeSet other= (TypeSet) o;
 100
 101                         return other.generated_2869635024761535811(this);
 102                 } else
 103                         return false;
 104         }
 105
 106         @Override
 107         public int hashCode() {
 108                 return 37 + fMembers.hashCode();
 109         }
 110
 111         /**
 112          * Computes and returns a <em>new</em> EnumeratedTypeSet representing the intersection of the
 113          * receiver with s2. Does not modify the receiver.
 114          * @param s2 the other type set
 115          */
 116         @Override
 117         protected TypeSet specialCasesIntersectedWith(TypeSet s2) {
 118                 if (s2 instanceof EnumeratedTypeSet) {
 119                         EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
 120
 121                         result.generated_3226133724554068663(s2, this);
 122                         if (result.size() > 0)
 123                                 return result;
 124                         else
 125                                 return getTypeSetEnvironment().getEmptyTypeSet();
 126                 }
 127                 return null;
 128         }
 129
 130         /**
 131          * Modifies this EnumeratedTypeSet to represent the intersection of the receiver with s2.
 132          * @param s2 the other type set
 133          */
 134         public void intersectWith(TypeSet s2) {
 135                 s2.generated_8067823756310198788(this);
 136         }
 137
 138         /**
 139          * @return a new TypeSet representing the set of all sub-types of the
 140          * types in the receiver
 141          */
 142         @Override
 143         public TypeSet subTypes() {
 144                 if (isUniverse())
 145                         return makeClone(); // subtypes(universe) = universe
 146
 147                 if (fMembers.contains(getJavaLangObject()))
 148                         return getTypeSetEnvironment().getUniverseTypeSet();
 149
 150                 return getTypeSetEnvironment().createSubTypesSet(this);
 151         }
 152
 153         public static EnumeratedTypeSet makeArrayTypesForElements(Iterator<TType> elemTypes, TypeSetEnvironment typeSetEnvironment) {
 154                 EnumeratedTypeSet result= new EnumeratedTypeSet(typeSetEnvironment);
 155
 156                 while (elemTypes.hasNext()) {
 157                         TType t= elemTypes.next();
 158                         result.add(TTypes.createArrayType(t, 1));
 159                 }
 160 //              result.initComplete();
 161                 return result;
 162         }
 163
 164         /**
 165          * @return a new TypeSet representing the set of all super-types of the
 166          * types in the receiver
 167          */
 168         @Override
 169         public TypeSet superTypes() {
 170                 if (isUniverse())
 171                         return makeClone(); // The supertypes of the universe is the universe
 172
 173                 return getTypeSetEnvironment().createSuperTypesSet(this);
 174         }
 175
 176         @Override
 177         public TypeSet makeClone() {
 178                 EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
 179
 180                 result.fMembers.addAll(fMembers);
 181                 return generated_5827134700953768926(result);
 182         }
 183
 184         public TypeSet generated_5827134700953768926(EnumeratedTypeSet result) {
 185                 result.initComplete();
 186                 return result;
 187         }
 188
 189         /* (non-Javadoc)
 190          * @see java.util.Set#size()
 191          */
 192         public int size() {
 193                 return fMembers.size();
 194         }
 195
 196         /* (non-Javadoc)
 197          * @see java.util.Set#clear()
 198          */
 199         public void clear() {
 200                 if (isUniverse())
 201                         fMembers= new LinkedHashSet<TType>();
 202                 else
 203                         fMembers.clear();
 204         }
 205
 206         /* (non-Javadoc)
 207          * @see java.util.Set#isEmpty()
 208          */
 209         @Override
 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 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         @Override
 234         public boolean contains(TType t) {
 235                 if (isUniverse())
 236                         return true;
 237                 return fMembers.contains(t);
 238         }
 239
 240         /* (non-Javadoc)
 241          * @see java.util.Set#remove(java.lang.Object)
 242          */
 243         public boolean remove(TType t) {
 244                 if (isUniverse())
 245                         fMembers= cloneSet(fMembers);
 246                 return fMembers.remove(t);
 247         }
 248
 249         private Set<TType> cloneSet(Set<TType> members) {
 250                 Set<TType> result= new LinkedHashSet<TType>();
 251                 result.addAll(members);
 252                 return result;
 253         }
 254
 255         /* (non-Javadoc)
 256          * @see java.util.Set#addAll(java.util.Collection)
 257          */
 258         public boolean addAll(TypeSet s) {
 259                 return s.generated_6796883765105910290(this);
 260         }
 261
 262         @Override
 263         public TypeSet addedTo(TypeSet that) {
 264                 EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
 265
 266                 return result.generated_6517476918444688818(that, this);
 267         }
 268
 269         /* (non-Javadoc)
 270          * @see java.util.Set#containsAll(java.util.Collection)
 271          */
 272         @Override
 273         public boolean containsAll(TypeSet s) {
 274                 if (isUniverse())
 275                         return true;
 276                 return s.generated_1664523987958239483(this);
 277         }
 278
 279         /* (non-Javadoc)
 280          * @see java.util.Set#removeAll(java.util.Collection)
 281          */
 282         public boolean removeAll(EnumeratedTypeSet s) {
 283                 return s.generated_7123627706191311488(this);
 284         }
 285
 286         /* (non-Javadoc)
 287          * @see java.util.Set#retainAll(java.util.Collection)
 288          */
 289         public boolean retainAll(TypeSet s) {
 290                 if (s.isUniverse()) return false;
 291
 292                 EnumeratedTypeSet ets= (EnumeratedTypeSet) s;
 293
 294                 return ets.generated_1055409160243982945(this);
 295         }
 296
 297         /* (non-Javadoc)
 298          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#isSingleton()
 299          */
 300         @Override
 301         public boolean isSingleton() {
 302                 return fMembers.size() == 1;
 303         }
 304
 305         /* (non-Javadoc)
 306          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#anyMember()
 307          */
 308         @Override
 309         public TType anyMember() {
 310                 return fMembers.iterator().next();
 311         }
 312
 313         /* (non-Javadoc)
 314          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#upperBound()
 315          */
 316         @Override
 317         public TypeSet upperBound() {
 318                 if (fMembers.size() == 1)
 319                         return new SingletonTypeSet(fMembers.iterator().next(), getTypeSetEnvironment());
 320                 if (fMembers.contains(getJavaLangObject()))
 321                         return new SingletonTypeSet(getJavaLangObject(), getTypeSetEnvironment());
 322
 323                 EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
 324
 325                 // Add to result each element of fMembers that has no proper supertype in fMembers
 326                 result.fMembers.addAll(fMembers);
 327                 for(Iterator<TType> iter= fMembers.iterator(); iter.hasNext(); ) {
 328                         TType t= iter.next();
 329
 330                         if (t.isArrayType()) {
 331                                 ArrayType at= (ArrayType) t;
 332                                 int numDims= at.getDimensions();
 333                                 for(Iterator<TType> subIter=TTypes.getAllSubTypesIterator(at.getElementType()); subIter.hasNext(); ) {
 334                                         result.fMembers.remove(TTypes.createArrayType(subIter.next(), numDims));
 335                                 }
 336                         } else {
 337                                 for (Iterator<TType> iterator= TTypes.getAllSubTypesIterator(t); iterator.hasNext();) {
 338                                         result.fMembers.remove(iterator.next());
 339                                 }
 340                         }
 341                 }
 342                 return generated_2336618344135692914(result);
 343         }
 344
 345         public TypeSet generated_2336618344135692914(EnumeratedTypeSet result) {
 346                 result.initComplete();
 347                 return result;
 348         }
 349
 350         /* (non-Javadoc)
 351          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#lowerBound()
 352          */
 353         @Override
 354         public TypeSet lowerBound() {
 355                 if (fMembers.size() == 1)
 356                         return new SingletonTypeSet(fMembers.iterator().next(), getTypeSetEnvironment());
 357
 358                 EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
 359
 360                 // Add to result each element of fMembers that has no proper subtype in fMembers
 361                 result.fMembers.addAll(fMembers);
 362
 363                 for(Iterator<TType> iter= fMembers.iterator(); iter.hasNext(); ) {
 364                         TType t= iter.next();
 365
 366                         // java.lang.Object is only in the lower bound if fMembers consists
 367                         // of only java.lang.Object, but that case is handled above.
 368                         if (t.equals(getJavaLangObject())) {
 369                                 result.fMembers.remove(t);
 370                                 continue;
 371                         }
 372
 373                         if (t instanceof ArrayType) {
 374                                 ArrayType at= (ArrayType) t;
 375                                 int numDims= at.getDimensions();
 376                                 for(Iterator<TType> superIter=TTypes.getAllSuperTypesIterator(at.getElementType()); superIter.hasNext(); ) {
 377                                         result.fMembers.remove(TTypes.createArrayType(superIter.next(), numDims));
 378                                 }
 379                         } else {
 380                                 for (Iterator<TType> iterator= TTypes.getAllSuperTypesIterator(t); iterator.hasNext();) {
 381                                         result.generated_6359776099616909620(this, iterator);
 382                                 }
 383                         }
 384                 }
 385                 if (result.size() > 0)
 386                         return result;
 387                 else
 388                         return getTypeSetEnvironment().getEmptyTypeSet();
 389         }
 390
 391         /* (non-Javadoc)
 392          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueLowerBound()
 393          */
 394         @Override
 395         public boolean hasUniqueLowerBound() {
 396                 return fMembers.size() == 1;
 397         }
 398
 399         /* (non-Javadoc)
 400          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueUpperBound()
 401          */
 402         @Override
 403         public boolean hasUniqueUpperBound() {
 404                 return fMembers.size() == 1;
 405         }
 406
 407         /* (non-Javadoc)
 408          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueLowerBound()
 409          */
 410         @Override
 411         public TType uniqueLowerBound() {
 412                 if (fMembers.size() == 1)
 413                         return fMembers.iterator().next();
 414                 return null;
 415         }
 416
 417         /* (non-Javadoc)
 418          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueUpperBound()
 419          */
 420         @Override
 421         public TType uniqueUpperBound() {
 422                 if (fMembers.size() == 1)
 423                         return fMembers.iterator().next();
 424                 return null;
 425         }
 426
 427         /* (non-Javadoc)
 428          * @see java.util.Set#iterator()
 429          */
 430         @Override
 431         public Iterator<TType> iterator() {
 432                 return fMembers.iterator();
 433         }
 434
 435         /**
 436          * Limits the display of set elements to the first sMaxElements.
 437          */
 438         private static final int sMaxElements= 10; // Integer.MAX_VALUE;
 439
 440         /*
 441          * (non-Javadoc)
 442          * @see java.lang.Object#toString()
 443          */
 444         @Override
 445         public String toString() {
 446                 StringBuffer b= new StringBuffer();
 447                 b.append("{" + fID+ ":"); //$NON-NLS-1$ //$NON-NLS-2$
 448                 if (isUniverse())
 449                         b.append(" <universe>"); //$NON-NLS-1$
 450                 else {
 451                         int count=0;
 452                         Iterator<TType> iter;
 453                         for(iter= iterator(); iter.hasNext() && count < sMaxElements; count++) {
 454                                 TType type= iter.next();
 455                                 b.append(' ')
 456                                  .append(type.getPrettySignature());
 457                                 if (iter.hasNext())
 458                                         b.append(',');
 459                         }
 460                         if (iter.hasNext())
 461                                 b.append(" ..."); //$NON-NLS-1$
 462                 }
 463                 b.append(" }"); //$NON-NLS-1$
 464                 return b.toString();
 465         }
 466
 467         /* (non-Javadoc)
 468          * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#enumerate()
 469          */
 470         @Override
 471         public EnumeratedTypeSet enumerate() {
 472                 return this; // (EnumeratedTypeSet) makeClone();
 473         }
 474
 475         public void initComplete() {
 476                 Assert.isTrue(! fMembers.isEmpty());
 477         }
 478
 479         public TypeSet generated_5630666201266944978(TypeSet that) {
 480                 addAll(that);
 481                 return this;
 482         }
 483
 484         public EnumeratedTypeSet generated_6250131234113279204(TypeSetUnion typesetunion) {
 485                 addAll(typesetunion.fRHS.enumerate());
 486                 return this;
 487         }
 488
 489         public void generated_3226133724554068663(TypeSet s2, EnumeratedTypeSet enumeratedtypeset) {
 490                 addAll(enumeratedtypeset); // copy first since retainAll() modifies in-place
 491                 retainAll(s2);
 492         }
 493
 494         public TypeSet generated_6517476918444688818(TypeSet that, EnumeratedTypeSet enumeratedtypeset) {
 495                 addAll(enumeratedtypeset);
 496                 addAll(that);
 497                 initComplete();
 498                 return this;
 499         }
 500
 501         public boolean generated_7123627706191311488(EnumeratedTypeSet enumeratedtypeset) {
 502                 if (enumeratedtypeset.isUniverse())
 503                         enumeratedtypeset.fMembers= enumeratedtypeset.cloneSet(enumeratedtypeset.fMembers);
 504                 return enumeratedtypeset.fMembers.removeAll(fMembers);
 505         }
 506
 507         public boolean generated_1055409160243982945(EnumeratedTypeSet enumeratedtypeset) {
 508                 if (enumeratedtypeset.isUniverse()) {
 509                         enumeratedtypeset.fMembers= enumeratedtypeset.cloneSet(fMembers);
 510                         return true;
 511                 } else
 512                         return enumeratedtypeset.fMembers.retainAll(fMembers);
 513         }
 514
 515         public void generated_6359776099616909620(EnumeratedTypeSet enumeratedtypeset, Iterator<TType> iterator) {
 516                 fMembers.remove(iterator.next());
 517         }
 518
 519         public void generated_1642096082428232797(ArrayTypeSet arraytypeset) {
 520                 for(Iterator<TType> iter= arraytypeset.fElemTypeSet.iterator(); iter.hasNext(); ) {
 521                         TType t= iter.next();
 522                         add(TTypes.createArrayType(t, 1));
 523                 }
 524                 initComplete();
 525         }
 526
 527         public EnumeratedTypeSet generated_7528185341646899938() {
 528                 initComplete();
 529                 return this;
 530         }
 531
 532         public void generated_6258089802901260053(SuperTypesOfSingleton supertypesofsingleton) {
 533                 add(supertypesofsingleton.fLowerBound);
 534                 initComplete();
 535         }
 536
 537         public void generated_8080557805498483091(SubTypesSet subtypesset) {
 538                 for(Iterator<TType> iter= subtypesset.fUpperBounds.iterator(); iter.hasNext(); ) {
 539                         TType ub= iter.next();
 540
 541                         if (ub instanceof ArrayType) {
 542                                 ArrayType at= (ArrayType) ub;
 543                                 int numDims= at.getDimensions();
 544                                 for(Iterator<TType> elemSubIter=TTypes.getAllSubTypesIterator(at.getElementType()); elemSubIter.hasNext(); )
 545                                         add(TTypes.createArrayType(elemSubIter.next(), numDims));
 546                         } else {
 547                                 for (Iterator<TType> iterator= TTypes.getAllSubTypesIterator(ub); iterator.hasNext();) {
 548                                         fMembers.add(iterator.next());
 549                                 }
 550                         }
 551                         add(ub);
 552                 }
 553         }
 554
 555         public boolean generated_747711718974346131(SuperTypesSet supertypesset, boolean anyLBIsIntfOrArray) {
 556                 for(Iterator<TType> iter= supertypesset.fLowerBounds.iterator(); iter.hasNext(); ) {
 557                         TType lb= iter.next();
 558
 559                         if (lb instanceof ArrayType) {
 560                                 ArrayType at= (ArrayType) lb;
 561                                 int numDims= at.getDimensions();
 562                                 for(Iterator<TType> elemSuperIter=TTypes.getAllSuperTypesIterator(at.getElementType()); elemSuperIter.hasNext(); )
 563                                         add(TTypes.createArrayType(elemSuperIter.next(), numDims));
 564                                 anyLBIsIntfOrArray= true;
 565                         } else {
 566                                 for (Iterator<TType> iterator= TTypes.getAllSuperTypesIterator(lb); iterator.hasNext(); )
 567                                 fMembers.add(iterator.next());
 568                         }
 569                         add(lb);
 570                 }
 571                 return anyLBIsIntfOrArray;
 572         }
 573
 574         public void generated_2584938505133572049(SubTypesOfSingleton subtypesofsingleton) {
 575                 add(subtypesofsingleton.fUpperBound);
 576                 initComplete();
 577         }
 578
 579 }