Java TypeVariable2类代码示例

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
private static ParameterizedType rewriteConstraintVariable(
    ConstraintVariable2 cv,
    CompilationUnitRewrite rewrite,
    InferTypeArgumentsTCModel tCModel,
    boolean leaveUnconstraindRaw,
    SimpleType[] types) {
  if (cv instanceof CollectionElementVariable2) {
    ConstraintVariable2 parentElement =
        ((CollectionElementVariable2) cv).getParentConstraintVariable();
    if (parentElement instanceof TypeVariable2) {
      TypeVariable2 typeCv = (TypeVariable2) parentElement;
      return rewriteTypeVariable(typeCv, rewrite, tCModel, leaveUnconstraindRaw, types);
    } else {
      // only rewrite type variables
    }
  }
  return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
public TypeVariable2 makeTypeVariable(Type type) {
  ICompilationUnit cu = RefactoringASTParser.getCompilationUnit(type);
  TType ttype = getBoxedType(type.resolveBinding(), /*no boxing*/ null);
  if (ttype == null) return null;

  CompilationUnitRange range = new CompilationUnitRange(cu, type);
  TypeVariable2 typeVariable = new TypeVariable2(ttype, range);
  TypeVariable2 storedCv = (TypeVariable2) storedCv(typeVariable);
  if (storedCv == typeVariable) {
    fCuScopedConstraintVariables.add(storedCv);
    if (isAGenericType(ttype)) makeElementVariables(storedCv, ttype);
    makeArrayElementVariable(storedCv);
    if (fStoreToString) storedCv.setData(ConstraintVariable2.TO_STRING, type.toString());
  }
  return storedCv;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
public TypeVariable2 makeTypeVariable(Type type) {
	ICompilationUnit cu= RefactoringASTParser.getCompilationUnit(type);
	TType ttype= getBoxedType(type.resolveBinding(), /*no boxing*/null);
	if (ttype == null)
		return null;

	CompilationUnitRange range= new CompilationUnitRange(cu, type);
	TypeVariable2 typeVariable= new TypeVariable2(ttype, range);
	TypeVariable2 storedCv= (TypeVariable2) storedCv(typeVariable);
	if (storedCv == typeVariable) {
		fCuScopedConstraintVariables.add(storedCv);
		if (isAGenericType(ttype))
			makeElementVariables(storedCv, ttype);
		makeArrayElementVariable(storedCv);
		if (fStoreToString)
			storedCv.setData(ConstraintVariable2.TO_STRING, type.toString());
	}
	return storedCv;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
@Override
public void endVisit(ArrayCreation node) {
  ArrayType arrayType = node.getType();
  TypeVariable2 arrayTypeCv = (TypeVariable2) getConstraintVariable(arrayType);
  if (arrayTypeCv == null) return;
  setConstraintVariable(node, arrayTypeCv);
  // TODO: constraints for array initializer?
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
/**
 * Creates an exception variable.
 *
 * @param name the name of the thrown exception
 * @return the created exception variable, or <code>null</code>
 */
public final ConstraintVariable2 createExceptionVariable(final Name name) {
	final ITypeBinding binding= name.resolveTypeBinding();
	if (isConstrainedType(binding))
		return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(name), name)));
	return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
/**
 * Creates a type variable.
 *
 * @param type the type binding
 * @param range the compilation unit range
 * @return the created type variable, or <code>null</code>
 */
public final ConstraintVariable2 createTypeVariable(ITypeBinding type, final CompilationUnitRange range) {
	if (type.isArray())
		type= type.getElementType();
	if (isConstrainedType(type))
		return fConstraintVariables.addExisting(new TypeVariable2(createTType(type), range));
	return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
private static ParameterizedType rewriteConstraintVariable(ConstraintVariable2 cv, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel, boolean leaveUnconstraindRaw, SimpleType[] types) {
	if (cv instanceof CollectionElementVariable2) {
		ConstraintVariable2 parentElement= ((CollectionElementVariable2) cv).getParentConstraintVariable();
		if (parentElement instanceof TypeVariable2) {
			TypeVariable2 typeCv= (TypeVariable2) parentElement;
			return rewriteTypeVariable(typeCv, rewrite, tCModel, leaveUnconstraindRaw, types);
		} else {
			//only rewrite type variables
		}
	}
	return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
private static ParameterizedType rewriteTypeVariable(TypeVariable2 typeCv, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel, boolean leaveUnconstraindRaw, SimpleType[] types) {
	ASTNode node= typeCv.getRange().getNode(rewrite.getRoot());
	if (node instanceof Name && node.getParent() instanceof Type) {
		Type originalType= (Type) node.getParent();

		if (types != null && !has(types, originalType))
			return null;

		// Must rewrite all type arguments in one batch. Do the rewrite when the first one is encountered; skip the others.
		Object rewritten= originalType.getProperty(REWRITTEN);
		if (rewritten == REWRITTEN)
			return null;
		originalType.setProperty(REWRITTEN, REWRITTEN);

		ArrayList<CollectionElementVariable2> typeArgumentCvs= getTypeArgumentCvs(typeCv, tCModel);
		Type[] typeArguments= getTypeArguments(originalType, typeArgumentCvs, rewrite, tCModel, leaveUnconstraindRaw);
		if (typeArguments == null)
			return null;

		Type movingType= (Type) rewrite.getASTRewrite().createMoveTarget(originalType);
		ParameterizedType newType= rewrite.getAST().newParameterizedType(movingType);

		for (int i= 0; i < typeArguments.length; i++) {
			newType.typeArguments().add(typeArguments[i]);
		}

		rewrite.getASTRewrite().replace(originalType, newType, rewrite.createGroupDescription(RefactoringCoreMessages.InferTypeArgumentsRefactoring_addTypeArguments));
		return newType;
	}  else {//TODO: other node types?
		return null;
	}
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
@Override
public void endVisit(ArrayCreation node) {
	ArrayType arrayType= node.getType();
	TypeVariable2 arrayTypeCv= (TypeVariable2) getConstraintVariable(arrayType);
	if (arrayTypeCv == null)
		return;
	setConstraintVariable(node, arrayTypeCv);
	//TODO: constraints for array initializer?
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
/**
 * Creates an exception variable.
 *
 * @param name the name of the thrown exception
 * @return the created exception variable
 */
public final ConstraintVariable2 createExceptionVariable(final Name name) {
	final ITypeBinding binding= name.resolveTypeBinding();
	if (isConstrainedType(binding))
		return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(name), name)));
	return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
/**
 * Creates a type variable.
 *
 * @param type the type binding
 * @param range the compilation unit range
 * @return the created type variable
 */
public final ConstraintVariable2 createTypeVariable(ITypeBinding type, final CompilationUnitRange range) {
	if (type.isArray())
		type= type.getElementType();
	if (isConstrainedType(type))
		return fConstraintVariables.addExisting(new TypeVariable2(createTType(type), range));
	return null;
}
 

import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2; //导入依赖的package包/类
private static ParameterizedType rewriteTypeVariable(
    TypeVariable2 typeCv,
    CompilationUnitRewrite rewrite,
    InferTypeArgumentsTCModel tCModel,
    boolean leaveUnconstraindRaw,
    SimpleType[] types) {
  ASTNode node = typeCv.getRange().getNode(rewrite.getRoot());
  if (node instanceof Name && node.getParent() instanceof Type) {
    Type originalType = (Type) node.getParent();

    if (types != null && !has(types, originalType)) return null;

    // Must rewrite all type arguments in one batch. Do the rewrite when the first one is
    // encountered; skip the others.
    Object rewritten = originalType.getProperty(REWRITTEN);
    if (rewritten == REWRITTEN) return null;
    originalType.setProperty(REWRITTEN, REWRITTEN);

    ArrayList<CollectionElementVariable2> typeArgumentCvs = getTypeArgumentCvs(typeCv, tCModel);
    Type[] typeArguments =
        getTypeArguments(originalType, typeArgumentCvs, rewrite, tCModel, leaveUnconstraindRaw);
    if (typeArguments == null) return null;

    Type movingType = (Type) rewrite.getASTRewrite().createMoveTarget(originalType);
    ParameterizedType newType = rewrite.getAST().newParameterizedType(movingType);

    for (int i = 0; i < typeArguments.length; i++) {
      newType.typeArguments().add(typeArguments[i]);
    }

    rewrite
        .getASTRewrite()
        .replace(
            originalType,
            newType,
            rewrite.createGroupDescription(
                RefactoringCoreMessages.InferTypeArgumentsRefactoring_addTypeArguments));
    return newType;
  } else { // TODO: other node types?
    return null;
  }
}