Java ClassOrInterfaceType.setTypeArgs方法代码示例

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
public static ClassOrInterfaceType getResolvedName(final JavaType target,
        final JavaType current, final com.github.javaparser.ast.CompilationUnit compilationUnit) {
    final NameExpr nameExpr = JavaParserUtils.importTypeIfRequired(target,
            compilationUnit.getImports(), current);
    final ClassOrInterfaceType resolvedName = JavaParserUtils
            .getClassOrInterfaceType(nameExpr);
    if (current.getParameters() != null
            && current.getParameters().size() > 0) {
        resolvedName.setTypeArgs(new ArrayList<Type>());
        for (final JavaType param : current.getParameters()) {
            resolvedName.getTypeArgs().add(
                    getResolvedName(target, param, compilationUnit));
        }
    }

    return resolvedName;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
public static ReferenceType importParametersForType(
        final JavaType targetType, final List<ImportDeclaration> imports,
        final JavaType typeToImport) {
    Validate.notNull(targetType, "Target type is required");
    Validate.notNull(imports, "Compilation unit imports required");
    Validate.notNull(typeToImport, "Java type to import is required");

    final ClassOrInterfaceType cit = getClassOrInterfaceType(importTypeIfRequired(
            targetType, imports, typeToImport));
    
    // Add any type arguments presented for the return type
    if (typeToImport.getParameters().size() > 0) {
        final List<Type> typeArgs = new ArrayList<Type>();
        cit.setTypeArgs(typeArgs);
        for (final JavaType parameter : typeToImport
                .getParameters()) {
            typeArgs.add(JavaParserUtils.importParametersForType(
                    targetType,
                    imports, parameter));
        }
    }
    return  new ReferenceType(cit);
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
/**
 * Creates a socket hint declaration from the constructor.
 *
 * @return The field declaration
 */
public FieldDeclaration getDeclaration() {
  final int modifiers = ModifierSet.addModifier(ModifierSet.FINAL, ModifierSet.PRIVATE);

  final ClassOrInterfaceType socketHintType = new ClassOrInterfaceType(SOCKET_HINT_CLASS_NAME);
  socketHintType.setTypeArgs(Collections.singletonList(genericType));

  final ClassOrInterfaceType socketHintBuilderType = new ClassOrInterfaceType(new
      ClassOrInterfaceType(SOCKET_HINT_CLASS_NAME), SOCKET_HINT_BUILDER_CLASS_NAME);

  final List<VariableDeclarator> variableDeclarations = new ArrayList<>();
  for (DefinedParamType paramType : paramTypes) {
    // Don't generate hint for ignored param
    if (paramType.isIgnored()) {
      continue;
    }

    String hintName = paramType.getName();
    // The variableId
    final String fullHintName = hintName
        + (isOutput() ? OUTPUT_POSTFIX : INPUT_POSTFIX)
        + HINT_POSTFIX;
    // The name hint of the socket hint
    final StringLiteralExpr stringLiteralExpr = new StringLiteralExpr(hintName);

    variableDeclarations.add(
        new VariableDeclarator(
            new VariableDeclaratorId(fullHintName),
            // Create new instantiation of type socket hint type
            socketHintBuilder(socketHintBuilderType, stringLiteralExpr, paramType)
        )
    );
  }
  if (variableDeclarations.isEmpty()) {
    return null;
  }

  return new FieldDeclaration(modifiers, socketHintType, variableDeclarations);
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
public static Type getSocketReturnParam(String socketNameType) {
  ClassOrInterfaceType socketType = new ClassOrInterfaceType(null, socketNameType);
  socketType.setTypeArgs(Arrays.asList(new WildcardType()));
  return new ReferenceType(socketType, 1);
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
private Expression generateCopyExpression(DefinedParamType type, String inputParmId, int
    inputIndex, String outputParamId, int outputIndex) {
  // GOAL: ((InputSocket<Mat>) inputs[0]).getValue().get().assignTo(((OutputSocket<Mat>)
  // outputs[0]).getValue().get());
  final ClassOrInterfaceType outputType = new ClassOrInterfaceType("OutputSocket");
  final ClassOrInterfaceType inputType = new ClassOrInterfaceType("InputSocket");
  outputType.setTypeArgs(Collections.singletonList(type.getType()));
  inputType.setTypeArgs(Collections.singletonList(type.getType()));

  final MethodCallExpr copyExpression = new MethodCallExpr(
      new MethodCallExpr(
          getOrSetValueExpression(
              new EnclosedExpr(
                  new CastExpr(
                      inputType,
                      arrayAccessExpr(inputParmId, inputIndex)
                  )
              ),
              null
          ),
          "get"
      ),
      "assignTo",
      Collections.singletonList(
          new MethodCallExpr(
              getOrSetValueExpression(
                  new EnclosedExpr(
                      new CastExpr(
                          outputType,
                          arrayAccessExpr(outputParamId, outputIndex)
                      )
                  ),
                  null
              ),
              "get"
          )
      )
  );
  copyExpression.setComment(new BlockComment(
      " Sets the value of the input Mat to the output because this operation does not have a " +
          "destination Mat. "
  ));
  return copyExpression;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入方法依赖的package包/类
@Override
public ClassOrInterfaceType doMerge(ClassOrInterfaceType first, ClassOrInterfaceType second) {

    ClassOrInterfaceType cift = new ClassOrInterfaceType();

    cift.setName(first.getName());
    cift.setScope(first.getScope());
    cift.setTypeArgs(first.getTypeArgs());

    cift.setAnnotations(mergeCollections(first.getAnnotations(), second.getAnnotations()));

    return cift;
}