Java TType.equals方法代码示例

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
public boolean contains(TType t) {
  if (t.equals(getJavaLangObject())) return true;
  if (!(t instanceof ArrayType)) return false;

  ArrayType at = (ArrayType) t;
  TType atElemType = at.getComponentType();

  if (fElemTypeSet.contains(atElemType)) // try to avoid enumeration
  return true;

  for (Iterator<TType> iter = fElemTypeSet.iterator(); iter.hasNext(); ) {
    TType elemType = iter.next();

    if (TTypes.canAssignTo(elemType, atElemType)) return true;
  }
  return false;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@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();
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
public boolean contains(TType t) {
  if (fEnumCache != null) return fEnumCache.contains(t);

  if (t.equals(getJavaLangObject())) return true;
  if (fLowerBounds.contains(t)) return true;

  // Find the "lower frontier", i.e. the lower bound, and see whether
  // the given type is a supertype of any of those.
  for (Iterator<TType> lbIter = fLowerBounds /*.lowerBound() */.iterator(); lbIter.hasNext(); ) {
    TType lb = lbIter.next();

    if (TTypes.canAssignTo(lb, t)) return true;
  }
  return false;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
private void findCastsToRemove(CastVariable2[] castVariables) {
  for (int i = 0; i < castVariables.length; i++) {
    CastVariable2 castCv = castVariables[i];
    ConstraintVariable2 expressionVariable = castCv.getExpressionVariable();
    TType chosenType = InferTypeArgumentsConstraintsSolver.getChosenType(expressionVariable);
    TType castType = castCv.getType();
    TType expressionType = expressionVariable.getType();
    if (chosenType != null && TTypes.canAssignTo(chosenType, castType)) {
      if (chosenType.equals(expressionType))
        continue; // The type has not changed. Don't remove the cast, since it could be
      // there to get access to default-visible members or to
      // unify types of conditional expressions.
      fUpdate.addCastToRemove(castCv);

    } else if (expressionVariable instanceof ArrayTypeVariable2
        && castType.isArrayType()) { // bug 97258
      ArrayElementVariable2 arrayElementCv = fTCModel.getArrayElementVariable(expressionVariable);
      if (arrayElementCv == null) continue;
      TType chosenArrayElementType =
          InferTypeArgumentsConstraintsSolver.getChosenType(arrayElementCv);
      if (chosenArrayElementType != null
          && TTypes.canAssignTo(
              chosenArrayElementType, ((ArrayType) castType).getComponentType())) {
        if (expressionType instanceof ArrayType
            && chosenArrayElementType.equals(((ArrayType) expressionType).getComponentType()))
          continue; // The type has not changed. Don't remove the cast, since it could be
        // there to unify types of conditional expressions.
        fUpdate.addCastToRemove(castCv);
      }
    }
  }
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
protected TypeSet specialCasesIntersectedWith(TypeSet other) {
  if (other.isSingleton() && other.anyMember().equals(fLowerBound))
    return other; // xsect(superTypes(A),A) = A

  if (other instanceof SuperTypesOfSingleton) {
    SuperTypesOfSingleton otherSuper = (SuperTypesOfSingleton) other;

    if (TTypes.canAssignTo(otherSuper.fLowerBound, fLowerBound)) return this;
    if (TTypes.canAssignTo(fLowerBound, otherSuper.fLowerBound)) return otherSuper;
  } else if (other.hasUniqueUpperBound()) {
    TType otherUpper = other.uniqueUpperBound();

    if (otherUpper.equals(fLowerBound))
      return new SingletonTypeSet(fLowerBound, getTypeSetEnvironment());
    if ((otherUpper != fLowerBound && TTypes.canAssignTo(otherUpper, fLowerBound))
        || !TTypes.canAssignTo(fLowerBound, otherUpper))
      return getTypeSetEnvironment().getEmptyTypeSet();
  }
  //		else if (other instanceof SuperTypesSet) {
  //			SuperTypesSet otherSub= (SuperTypesSet) other;
  //			TypeSet otherLowers= otherSub.lowerBound();
  //
  //			for(Iterator iter= otherLowers.iterator(); iter.hasNext(); ) {
  //				TType t= (TType) iter.next();
  //
  //				if ()
  //			}
  //		}
  return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
public TypeSet specialCasesIntersectedWith(TypeSet other) {
  if (other.isSingleton() && other.anyMember().equals(fUpperBound))
    return other; // xsect(subTypes(A),A) = A

  if (other instanceof SubTypesOfSingleton) {
    SubTypesOfSingleton otherSub = (SubTypesOfSingleton) other;

    if (TTypes.canAssignTo(otherSub.fUpperBound, fUpperBound)) return otherSub; // .makeClone();
    if (TTypes.canAssignTo(fUpperBound, otherSub.fUpperBound)) return this; // makeClone();
  } else if (other.hasUniqueLowerBound()) {
    TType otherLower = other.uniqueLowerBound();

    if (otherLower.equals(fUpperBound))
      return new SingletonTypeSet(fUpperBound, getTypeSetEnvironment());
    if (otherLower != fUpperBound && TTypes.canAssignTo(fUpperBound, otherLower)
        || !TTypes.canAssignTo(otherLower, fUpperBound))
      return getTypeSetEnvironment().getEmptyTypeSet();
  }
  //		else if (other instanceof SubTypesSet) {
  //			SubTypesSet otherSub= (SubTypesSet) other;
  //			TypeSet otherUppers= otherSub.upperBound();
  //
  //			for(Iterator iter= otherUppers.iterator(); iter.hasNext(); ) {
  //				TType t= (TType) iter.next();
  //
  //				if ()
  //			}
  //		}
  return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@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.fMembers.remove(iterator.next());
      }
    }
  }
  if (result.size() > 0) return result;
  else return getTypeSetEnvironment().getEmptyTypeSet();
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
public boolean contains(TType t) {
  if (t.equals(fLowerBound)) return true;
  if (t.equals(getJavaLangObject())) return true;
  return TTypes.canAssignTo(fLowerBound, t);
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType; //导入方法依赖的package包/类
@Override
public boolean contains(TType t) {
  if (t.equals(fUpperBound)) return true;
  return TTypes.canAssignTo(t, fUpperBound);
}