--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Robert M. Fuhrer (rfuhrer@watson.ibm.com), IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets;
+
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import org.eclipse.core.runtime.Assert;
+
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.ArrayType;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TTypes;
+
+/**
+ * A type-safe wrapper for {@code Set<TType>} that also adds {@code TType}-specific
+ * functionality, e.g. subTypes() and superTypes().
+ */
+public class EnumeratedTypeSet extends TypeSet {
+ public static int sCount= 0;
+
+ static public int getCount() {
+ return sCount;
+ }
+
+ static public void resetCount() {
+ sCount= 0;
+ }
+
+ /**
+ * Set containing the TTypes in this EnumeratedTypeSet.
+ */
+ public Set<TType> fMembers= new LinkedHashSet<TType>();
+
+ /**
+ * Constructs a new EnumeratedTypeSet with the members of Set s in it.
+ * All elements of s must be TTypes.
+ *
+ * @param types the types
+ * @param typeSetEnvironment the environment
+ */
+ public EnumeratedTypeSet(Iterator<TType> types, TypeSetEnvironment typeSetEnvironment) {
+ super(typeSetEnvironment);
+ while (types.hasNext()) {
+ fMembers.add(types.next());
+ }
+ sCount++;
+ }
+
+ /**
+ * Constructs an empty EnumeratedTypeSet.
+ *
+ * @param typeSetEnvironment the environment
+ */
+ public EnumeratedTypeSet(TypeSetEnvironment typeSetEnvironment) {
+ super(typeSetEnvironment);
+ sCount++;
+ }
+
+ /**
+ * Constructs a new EnumeratedTypeSet with the given single TType in it.
+ *
+ * @param t the type
+ * @param typeSetEnvironment the environment
+ */
+ public EnumeratedTypeSet(TType t, TypeSetEnvironment typeSetEnvironment) {
+ super(typeSetEnvironment);
+ t.generated_3769340610219257430(this);
+ }
+
+ /**
+ * @return <code>true</code> iff this set represents the universe of TTypes
+ */
+ @Override
+ public boolean isUniverse() {
+ return false;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o instanceof EnumeratedTypeSet) {
+ EnumeratedTypeSet other= (EnumeratedTypeSet) o;
+
+ return fMembers.equals(other.fMembers);
+ } else if (o instanceof SingletonTypeSet) {
+ SingletonTypeSet other= (SingletonTypeSet) o;
+
+ return (fMembers.size() == 1) && fMembers.contains(other.anyMember());
+ } else if (o instanceof TypeSet) {
+ TypeSet other= (TypeSet) o;
+
+ return other.generated_2869635024761535811(this);
+ } else
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return 37 + fMembers.hashCode();
+ }
+
+ /**
+ * Computes and returns a <em>new</em> EnumeratedTypeSet representing the intersection of the
+ * receiver with s2. Does not modify the receiver.
+ * @param s2 the other type set
+ */
+ @Override
+ protected TypeSet specialCasesIntersectedWith(TypeSet s2) {
+ if (s2 instanceof EnumeratedTypeSet) {
+ EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
+
+ result.generated_3226133724554068663(s2, this);
+ if (result.size() > 0)
+ return result;
+ else
+ return getTypeSetEnvironment().getEmptyTypeSet();
+ }
+ return null;
+ }
+
+ /**
+ * Modifies this EnumeratedTypeSet to represent the intersection of the receiver with s2.
+ * @param s2 the other type set
+ */
+ public void intersectWith(TypeSet s2) {
+ s2.generated_8067823756310198788(this);
+ }
+
+ /**
+ * @return a new TypeSet representing the set of all sub-types of the
+ * types in the receiver
+ */
+ @Override
+ public TypeSet subTypes() {
+ if (isUniverse())
+ return makeClone(); // subtypes(universe) = universe
+
+ if (fMembers.contains(getJavaLangObject()))
+ return getTypeSetEnvironment().getUniverseTypeSet();
+
+ return getTypeSetEnvironment().createSubTypesSet(this);
+ }
+
+ public static EnumeratedTypeSet makeArrayTypesForElements(Iterator<TType> elemTypes, TypeSetEnvironment typeSetEnvironment) {
+ EnumeratedTypeSet result= new EnumeratedTypeSet(typeSetEnvironment);
+
+ while (elemTypes.hasNext()) {
+ TType t= elemTypes.next();
+ result.add(TTypes.createArrayType(t, 1));
+ }
+// result.initComplete();
+ return result;
+ }
+
+ /**
+ * @return a new TypeSet representing the set of all super-types of the
+ * types in the receiver
+ */
+ @Override
+ public TypeSet superTypes() {
+ if (isUniverse())
+ return makeClone(); // The supertypes of the universe is the universe
+
+ return getTypeSetEnvironment().createSuperTypesSet(this);
+ }
+
+ @Override
+ public TypeSet makeClone() {
+ EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
+
+ result.fMembers.addAll(fMembers);
+ return generated_5827134700953768926(result);
+ }
+
+ public TypeSet generated_5827134700953768926(EnumeratedTypeSet result) {
+ result.initComplete();
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#size()
+ */
+ public int size() {
+ return fMembers.size();
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#clear()
+ */
+ public void clear() {
+ if (isUniverse())
+ fMembers= new LinkedHashSet<TType>();
+ else
+ fMembers.clear();
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#isEmpty()
+ */
+ @Override
+ public boolean isEmpty() {
+ return fMembers.isEmpty();
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#toArray()
+ */
+ public TType[] toArray() {
+ return fMembers.toArray(new TType[fMembers.size()]);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#add(java.lang.Object)
+ */
+ public boolean add(TType t) {
+ // Doesn't make sense to do here what other methods do (copy-and-modify)
+ Assert.isTrue(!isUniverse(), "Someone's trying to expand the universe!"); //$NON-NLS-1$
+ return fMembers.add(t);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#contains(java.lang.Object)
+ */
+ @Override
+ public boolean contains(TType t) {
+ if (isUniverse())
+ return true;
+ return fMembers.contains(t);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#remove(java.lang.Object)
+ */
+ public boolean remove(TType t) {
+ if (isUniverse())
+ fMembers= cloneSet(fMembers);
+ return fMembers.remove(t);
+ }
+
+ private Set<TType> cloneSet(Set<TType> members) {
+ Set<TType> result= new LinkedHashSet<TType>();
+ result.addAll(members);
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#addAll(java.util.Collection)
+ */
+ public boolean addAll(TypeSet s) {
+ return s.generated_6796883765105910290(this);
+ }
+
+ @Override
+ public TypeSet addedTo(TypeSet that) {
+ EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
+
+ return result.generated_6517476918444688818(that, this);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#containsAll(java.util.Collection)
+ */
+ @Override
+ public boolean containsAll(TypeSet s) {
+ if (isUniverse())
+ return true;
+ return s.generated_1664523987958239483(this);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#removeAll(java.util.Collection)
+ */
+ public boolean removeAll(EnumeratedTypeSet s) {
+ return s.generated_7123627706191311488(this);
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#retainAll(java.util.Collection)
+ */
+ public boolean retainAll(TypeSet s) {
+ if (s.isUniverse()) return false;
+
+ EnumeratedTypeSet ets= (EnumeratedTypeSet) s;
+
+ return ets.generated_1055409160243982945(this);
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#isSingleton()
+ */
+ @Override
+ public boolean isSingleton() {
+ return fMembers.size() == 1;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#anyMember()
+ */
+ @Override
+ public TType anyMember() {
+ return fMembers.iterator().next();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#upperBound()
+ */
+ @Override
+ public TypeSet upperBound() {
+ if (fMembers.size() == 1)
+ return new SingletonTypeSet(fMembers.iterator().next(), getTypeSetEnvironment());
+ if (fMembers.contains(getJavaLangObject()))
+ return new SingletonTypeSet(getJavaLangObject(), getTypeSetEnvironment());
+
+ EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
+
+ // Add to result each element of fMembers that has no proper supertype in fMembers
+ result.fMembers.addAll(fMembers);
+ for(Iterator<TType> iter= fMembers.iterator(); iter.hasNext(); ) {
+ TType t= iter.next();
+
+ if (t.isArrayType()) {
+ ArrayType at= (ArrayType) t;
+ int numDims= at.getDimensions();
+ for(Iterator<TType> subIter=TTypes.getAllSubTypesIterator(at.getElementType()); subIter.hasNext(); ) {
+ result.fMembers.remove(TTypes.createArrayType(subIter.next(), numDims));
+ }
+ } else {
+ for (Iterator<TType> iterator= TTypes.getAllSubTypesIterator(t); iterator.hasNext();) {
+ result.fMembers.remove(iterator.next());
+ }
+ }
+ }
+ return generated_2336618344135692914(result);
+ }
+
+ public TypeSet generated_2336618344135692914(EnumeratedTypeSet result) {
+ result.initComplete();
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#lowerBound()
+ */
+ @Override
+ public TypeSet lowerBound() {
+ if (fMembers.size() == 1)
+ return new SingletonTypeSet(fMembers.iterator().next(), getTypeSetEnvironment());
+
+ EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment());
+
+ // Add to result each element of fMembers that has no proper subtype in fMembers
+ result.fMembers.addAll(fMembers);
+
+ for(Iterator<TType> iter= fMembers.iterator(); iter.hasNext(); ) {
+ TType t= iter.next();
+
+ // java.lang.Object is only in the lower bound if fMembers consists
+ // of only java.lang.Object, but that case is handled above.
+ if (t.equals(getJavaLangObject())) {
+ result.fMembers.remove(t);
+ continue;
+ }
+
+ if (t instanceof ArrayType) {
+ ArrayType at= (ArrayType) t;
+ int numDims= at.getDimensions();
+ for(Iterator<TType> superIter=TTypes.getAllSuperTypesIterator(at.getElementType()); superIter.hasNext(); ) {
+ result.fMembers.remove(TTypes.createArrayType(superIter.next(), numDims));
+ }
+ } else {
+ for (Iterator<TType> iterator= TTypes.getAllSuperTypesIterator(t); iterator.hasNext();) {
+ result.generated_6359776099616909620(this, iterator);
+ }
+ }
+ }
+ if (result.size() > 0)
+ return result;
+ else
+ return getTypeSetEnvironment().getEmptyTypeSet();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueLowerBound()
+ */
+ @Override
+ public boolean hasUniqueLowerBound() {
+ return fMembers.size() == 1;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#hasUniqueUpperBound()
+ */
+ @Override
+ public boolean hasUniqueUpperBound() {
+ return fMembers.size() == 1;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueLowerBound()
+ */
+ @Override
+ public TType uniqueLowerBound() {
+ if (fMembers.size() == 1)
+ return fMembers.iterator().next();
+ return null;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#uniqueUpperBound()
+ */
+ @Override
+ public TType uniqueUpperBound() {
+ if (fMembers.size() == 1)
+ return fMembers.iterator().next();
+ return null;
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Set#iterator()
+ */
+ @Override
+ public Iterator<TType> iterator() {
+ return fMembers.iterator();
+ }
+
+ /**
+ * Limits the display of set elements to the first sMaxElements.
+ */
+ private static final int sMaxElements= 10; // Integer.MAX_VALUE;
+
+ /*
+ * (non-Javadoc)
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ StringBuffer b= new StringBuffer();
+ b.append("{" + fID+ ":"); //$NON-NLS-1$ //$NON-NLS-2$
+ if (isUniverse())
+ b.append(" <universe>"); //$NON-NLS-1$
+ else {
+ int count=0;
+ Iterator<TType> iter;
+ for(iter= iterator(); iter.hasNext() && count < sMaxElements; count++) {
+ TType type= iter.next();
+ b.append(' ')
+ .append(type.getPrettySignature());
+ if (iter.hasNext())
+ b.append(',');
+ }
+ if (iter.hasNext())
+ b.append(" ..."); //$NON-NLS-1$
+ }
+ b.append(" }"); //$NON-NLS-1$
+ return b.toString();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet#enumerate()
+ */
+ @Override
+ public EnumeratedTypeSet enumerate() {
+ return this; // (EnumeratedTypeSet) makeClone();
+ }
+
+ public void initComplete() {
+ Assert.isTrue(! fMembers.isEmpty());
+ }
+
+ public TypeSet generated_5630666201266944978(TypeSet that) {
+ addAll(that);
+ return this;
+ }
+
+ public EnumeratedTypeSet generated_6250131234113279204(TypeSetUnion typesetunion) {
+ addAll(typesetunion.fRHS.enumerate());
+ return this;
+ }
+
+ public void generated_3226133724554068663(TypeSet s2, EnumeratedTypeSet enumeratedtypeset) {
+ addAll(enumeratedtypeset); // copy first since retainAll() modifies in-place
+ retainAll(s2);
+ }
+
+ public TypeSet generated_6517476918444688818(TypeSet that, EnumeratedTypeSet enumeratedtypeset) {
+ addAll(enumeratedtypeset);
+ addAll(that);
+ initComplete();
+ return this;
+ }
+
+ public boolean generated_7123627706191311488(EnumeratedTypeSet enumeratedtypeset) {
+ if (enumeratedtypeset.isUniverse())
+ enumeratedtypeset.fMembers= enumeratedtypeset.cloneSet(enumeratedtypeset.fMembers);
+ return enumeratedtypeset.fMembers.removeAll(fMembers);
+ }
+
+ public boolean generated_1055409160243982945(EnumeratedTypeSet enumeratedtypeset) {
+ if (enumeratedtypeset.isUniverse()) {
+ enumeratedtypeset.fMembers= enumeratedtypeset.cloneSet(fMembers);
+ return true;
+ } else
+ return enumeratedtypeset.fMembers.retainAll(fMembers);
+ }
+
+ public void generated_6359776099616909620(EnumeratedTypeSet enumeratedtypeset, Iterator<TType> iterator) {
+ fMembers.remove(iterator.next());
+ }
+
+ public void generated_1642096082428232797(ArrayTypeSet arraytypeset) {
+ for(Iterator<TType> iter= arraytypeset.fElemTypeSet.iterator(); iter.hasNext(); ) {
+ TType t= iter.next();
+ add(TTypes.createArrayType(t, 1));
+ }
+ initComplete();
+ }
+
+ public EnumeratedTypeSet generated_7528185341646899938() {
+ initComplete();
+ return this;
+ }
+
+ public void generated_6258089802901260053(SuperTypesOfSingleton supertypesofsingleton) {
+ add(supertypesofsingleton.fLowerBound);
+ initComplete();
+ }
+
+ public void generated_8080557805498483091(SubTypesSet subtypesset) {
+ for(Iterator<TType> iter= subtypesset.fUpperBounds.iterator(); iter.hasNext(); ) {
+ TType ub= iter.next();
+
+ if (ub instanceof ArrayType) {
+ ArrayType at= (ArrayType) ub;
+ int numDims= at.getDimensions();
+ for(Iterator<TType> elemSubIter=TTypes.getAllSubTypesIterator(at.getElementType()); elemSubIter.hasNext(); )
+ add(TTypes.createArrayType(elemSubIter.next(), numDims));
+ } else {
+ for (Iterator<TType> iterator= TTypes.getAllSubTypesIterator(ub); iterator.hasNext();) {
+ fMembers.add(iterator.next());
+ }
+ }
+ add(ub);
+ }
+ }
+
+ public boolean generated_747711718974346131(SuperTypesSet supertypesset, boolean anyLBIsIntfOrArray) {
+ for(Iterator<TType> iter= supertypesset.fLowerBounds.iterator(); iter.hasNext(); ) {
+ TType lb= iter.next();
+
+ if (lb instanceof ArrayType) {
+ ArrayType at= (ArrayType) lb;
+ int numDims= at.getDimensions();
+ for(Iterator<TType> elemSuperIter=TTypes.getAllSuperTypesIterator(at.getElementType()); elemSuperIter.hasNext(); )
+ add(TTypes.createArrayType(elemSuperIter.next(), numDims));
+ anyLBIsIntfOrArray= true;
+ } else {
+ for (Iterator<TType> iterator= TTypes.getAllSuperTypesIterator(lb); iterator.hasNext(); )
+ fMembers.add(iterator.next());
+ }
+ add(lb);
+ }
+ return anyLBIsIntfOrArray;
+ }
+
+ public void generated_2584938505133572049(SubTypesOfSingleton subtypesofsingleton) {
+ add(subtypesofsingleton.fUpperBound);
+ initComplete();
+ }
+
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff