| /******************************************************************************* |
| * Copyright (c) 2000, 2011 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * 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 org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; |
| import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TTypes; |
| |
| public class TypeSetIntersection extends TypeSet { |
| private TypeSet fLHS; |
| private TypeSet fRHS; |
| |
| public TypeSetIntersection(TypeSet lhs, TypeSet rhs) { |
| super(lhs.getTypeSetEnvironment()); |
| fLHS= lhs; |
| fRHS= rhs; |
| } |
| |
| /** |
| * @return Returns the LHS. |
| */ |
| public TypeSet getLHS() { |
| return fLHS; |
| } |
| |
| /** |
| * @return Returns the RHS. |
| */ |
| public TypeSet getRHS() { |
| return fRHS; |
| } |
| |
| @Override |
| public boolean isUniverse() { |
| return fLHS.isUniverse() && fRHS.isUniverse(); |
| } |
| |
| @Override |
| public TypeSet makeClone() { |
| return this; //new TypeSetIntersection(fLHS.makeClone(), fRHS.makeClone()); |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| if (fLHS.isEmpty() || fRHS.isEmpty()) |
| return true; |
| if (fLHS.isUniverse() || fRHS.isUniverse()) |
| return false; |
| // Another quick check we can make before jumping to the expensive stuff |
| if (fLHS.contains(getJavaLangObject()) && fRHS.contains(getJavaLangObject())) |
| return false; |
| |
| // TypeSet lhsLB= fLHS.lowerBound(); |
| // TypeSet rhsUB= fRHS.upperBound(); |
| // |
| // // Avoid the infinite recursion that will occur if lhsLB == fLHS && rhsUB == fRHS |
| // if ((!lhsLB.equals(fLHS) || !rhsUB.equals(fRHS)) && |
| // !lhsLB.intersectedWith(rhsUB).isEmpty()) |
| // return false; |
| // |
| // if (areAllSuperTypesOf(lhsLB, rhsUB)) |
| // return true; |
| // |
| // TypeSet lhsUB= fLHS.upperBound(); |
| // TypeSet rhsLB= fRHS.lowerBound(); |
| // |
| // if (!lhsUB.intersectedWith(rhsLB).isEmpty()) |
| // return false; |
| // |
| // if (areAllSuperTypesOf(rhsLB, lhsUB)) |
| // return true; |
| |
| return false; |
| } |
| |
| @Override |
| public boolean contains(TType t) { |
| return fLHS.contains(t) && fRHS.contains(t); |
| } |
| |
| @Override |
| public boolean containsAll(TypeSet s) { |
| return fLHS.containsAll(s) && fRHS.containsAll(s); |
| } |
| |
| @Override |
| public TypeSet subTypes() { |
| if (isUniverse() || contains(getJavaLangObject())) |
| return getTypeSetEnvironment().getUniverseTypeSet(); |
| // sub(xsect(sub(a),sub(b))) == xsect(sub(a),sub(b)) |
| if ((fLHS instanceof SubTypesSet || fLHS instanceof SubTypesOfSingleton) && |
| (fRHS instanceof SubTypesSet || fRHS instanceof SubTypesOfSingleton)) |
| return this; |
| return getTypeSetEnvironment().createSubTypesSet(this); |
| } |
| |
| @Override |
| public TypeSet superTypes() { |
| // super(xsect(super(a),super(b))) == xsect(super(a),super(b)) |
| if ((fLHS instanceof SuperTypesSet || fLHS instanceof SuperTypesOfSingleton) && |
| (fRHS instanceof SuperTypesSet || fRHS instanceof SuperTypesOfSingleton)) |
| return this; |
| return getTypeSetEnvironment().createSuperTypesSet(this); |
| } |
| |
| @Override |
| public TypeSet upperBound() { |
| if (fLHS.contains(getJavaLangObject()) && fRHS.contains(getJavaLangObject())) |
| return new SingletonTypeSet(getTypeSetEnvironment().getJavaLangObject(), getTypeSetEnvironment()); |
| |
| if (fEnumCache != null) return fEnumCache.upperBound(); |
| |
| EnumeratedTypeSet lhsSet= fLHS.enumerate(); |
| EnumeratedTypeSet rhsSet= fRHS.enumerate(); |
| TypeSet xsect= lhsSet.intersectedWith(rhsSet); |
| |
| return xsect.upperBound(); |
| } |
| |
| @Override |
| public TypeSet lowerBound() { |
| if (fLHS.hasUniqueLowerBound() && fRHS.hasUniqueLowerBound()) { |
| TType lhsBound= fLHS.uniqueLowerBound(); |
| TType rhsBound= fRHS.uniqueLowerBound(); |
| |
| if (lhsBound.equals(rhsBound)) |
| return new SingletonTypeSet(lhsBound, getTypeSetEnvironment()); |
| else if (TTypes.canAssignTo(lhsBound, rhsBound)) |
| return new SingletonTypeSet(rhsBound, getTypeSetEnvironment()); |
| else if (TTypes.canAssignTo(rhsBound, lhsBound)) |
| return new SingletonTypeSet(lhsBound, getTypeSetEnvironment()); |
| } |
| if (fEnumCache != null) return fEnumCache.lowerBound(); |
| |
| EnumeratedTypeSet lhsSet= fLHS.enumerate(); |
| EnumeratedTypeSet rhsSet= fRHS.enumerate(); |
| TypeSet xsect= lhsSet.intersectedWith(rhsSet); |
| |
| return xsect.lowerBound(); |
| } |
| |
| @Override |
| protected TypeSet specialCasesIntersectedWith(TypeSet s2) { |
| if (s2.equals(fLHS)) // xsect(s2,xsect(s2,?)) = xsect(s2,?) |
| return this; |
| if (s2.equals(fRHS)) // xsect(s2,xsect(?,s2)) = xsect(?,s2) |
| return this; |
| if (s2 instanceof TypeSetIntersection) { |
| TypeSetIntersection x2= (TypeSetIntersection) s2; |
| // |
| // The following should use a "quick equals()" guaranteed to be constant-time |
| // |
| // xsect(xsect(A,B),xsect(A,C)) = xsect(xsect(A,B),C) |
| if (fLHS.equals(x2.fLHS)) |
| return new TypeSetIntersection(this, x2.fRHS); |
| // xsect(xsect(A,B),xsect(C,A)) = xsect(xsect(A,B),C) |
| if (fLHS.equals(x2.fRHS)) |
| return new TypeSetIntersection(this, x2.fLHS); |
| // xsect(xsect(A,B),xsect(B,C)) = xsect(xsect(A,B),C) |
| if (fRHS.equals(x2.fLHS)) |
| return new TypeSetIntersection(this, x2.fRHS); |
| // xsect(xsect(A,B),xsect(C,B)) = xsect(xsect(A,B),C) |
| if (fRHS.equals(x2.fRHS)) |
| return new TypeSetIntersection(this, x2.fLHS); |
| } |
| return null; |
| } |
| |
| @Override |
| public boolean isSingleton() { |
| if (fEnumCache != null) return fEnumCache.isSingleton(); |
| |
| int count= 0; |
| for(Iterator<TType> lhsIter= fLHS.iterator(); lhsIter.hasNext(); ) { |
| TType t= lhsIter.next(); |
| if (fRHS.contains(t)) |
| count++; |
| if (count > 1) |
| return false; |
| } |
| return (count == 1); |
| } |
| |
| @Override |
| public TType anyMember() { |
| if (fEnumCache != null) return fEnumCache.anyMember(); |
| |
| for(Iterator<TType> lhsIter= fLHS.iterator(); lhsIter.hasNext(); ) { |
| TType t= lhsIter.next(); |
| if (fRHS.contains(t)) |
| return t; |
| } |
| return null; |
| } |
| |
| @Override |
| public Iterator<TType> iterator() { |
| return enumerate().iterator(); |
| |
| // return new Iterator() { |
| // private Iterator fLHSIter= fLHS.iterator(); |
| // private TType fNext= null; |
| // public void remove() { |
| // throw new IllegalStateException("Unimplemented"); |
| // } |
| // private void advance() { |
| // for(; fLHSIter.hasNext(); ) { |
| // TType t= (TType) fLHSIter.next(); |
| // if (fRHS.contains(t)) { |
| // fNext= t; |
| // break; |
| // } |
| // } |
| // } |
| // public boolean hasNext() { |
| // if (fNext == null) |
| // advance(); |
| // return fNext != null; |
| // } |
| // public Object next() { |
| // if (fNext == null) |
| // advance(); |
| // if (fNext == null) |
| // throw new NoSuchElementException("No more elements in TypeSetIntersection"); |
| // TType result= fNext; |
| // fNext= null; |
| // return result; |
| // } |
| // }; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o instanceof TypeSetIntersection) { |
| TypeSetIntersection other= (TypeSetIntersection) o; |
| return other.fLHS.equals(fLHS) && other.fRHS.equals(fRHS); |
| } else |
| return false; |
| } |
| |
| @Override |
| public int hashCode() { |
| return fLHS.hashCode() * 37 + fRHS.hashCode(); |
| } |
| |
| @Override |
| public String toString() { |
| return "<" + fID + ": intersect(" + fLHS + "," + fRHS + ")>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| } |
| |
| @Override |
| public boolean hasUniqueLowerBound() { |
| return false; |
| } |
| |
| @Override |
| public boolean hasUniqueUpperBound() { |
| return false; |
| } |
| |
| @Override |
| public TType uniqueLowerBound() { |
| return null; |
| } |
| |
| @Override |
| public TType uniqueUpperBound() { |
| return null; |
| } |
| |
| private EnumeratedTypeSet fEnumCache= null; |
| |
| @Override |
| public EnumeratedTypeSet enumerate() { |
| if (fEnumCache == null) { |
| EnumeratedTypeSet lhsSet= fLHS.enumerate(); |
| EnumeratedTypeSet rhsSet= fRHS.enumerate(); |
| fEnumCache= lhsSet.intersectedWith(rhsSet).enumerate(); |
| } |
| |
| return fEnumCache; |
| } |
| } |
