public void visit(ClassRefBuilder builder) { List<TypeRef> updatedArguments = new ArrayList<TypeRef>(); for (TypeRef arg : builder.getArguments()) { if (arg.equals(builderType.toInternalReference())) { updatedArguments.add(shallowInlineType.toInternalReference()); } else { updatedArguments.add(arg); } } builder.withArguments(updatedArguments); } }).build();
/** * Creates a {@link ClassRef} without bounds. */ public ClassRef toUnboundedReference() { return new ClassRefBuilder() .withDefinition(this) .withArguments(new TypeRef[0]) .build(); }
public void visit(ClassRefBuilder builder) { List<TypeRef> unwrappedArguments = new ArrayList<TypeRef>(); for (TypeRef argument : builder.getArguments()) { TypeRef key = getKeyForValue(GENERIC_MAPPINGS, argument); if (TRANSPARENT_REF.equals(key)) { continue; } else if (key != null) { unwrappedArguments.add(key); } else if (argument instanceof ClassRef) { unwrappedArguments.add(new ClassRefBuilder((ClassRef)argument).accept(UNWRAP_CLASSREF_VISITOR).build()); } else { unwrappedArguments.add(argument); } } builder.withArguments(unwrappedArguments); } };
/** * Creates a {@link ClassRef} for the current definition with the specified arguments. * * @param arguments The arguments to be passed to the reference. */ public ClassRef toReference(List<TypeRef> arguments) { List<TypeRef> actualArguments = new ArrayList<TypeRef>(); for (int i = 0; i < parameters.size(); i++) { if (i < arguments.size()) { actualArguments.add(arguments.get(i)); } else { actualArguments.add(new WildcardRef()); } } return new ClassRefBuilder() .withDefinition(this) .withArguments(actualArguments) .withAttributes(getAttributes()) .build(); }
/** * Creates a {@link ClassRef} for the current definition with the specified arguments. * * @param arguments The arguments to be passed to the reference. */ public ClassRef toReference(TypeRef... arguments) { List<TypeRef> actualArguments = new ArrayList<TypeRef>(); for (int i = 0; i < parameters.size(); i++) { if (i < arguments.length) { actualArguments.add(arguments[i]); } else { actualArguments.add(new WildcardRef()); } } return new ClassRefBuilder() .withDefinition(this) .withArguments(actualArguments) .withAttributes(getAttributes()) .build(); }
public TypeRef visitDeclared(DeclaredType t, Integer dimension) { List<TypeRef> arguments = new ArrayList<TypeRef>(); for (TypeMirror typeMirror : t.getTypeArguments()) { TypeRef arg = typeMirror.accept(this, dimension); if (arg != null) { arguments.add(arg); } } TypeDef typeDef = new TypeDefElementVisitor().visit(t.asElement()).build(); return new ClassRefBuilder() .withDefinition(typeDef) .withDimensions(dimension) .withArguments(arguments) .build(); }
/** * Creates a {@link ClassRef} for internal use inside the scope of the type (methods, properties * etc). It uses as arguments the same 'letters' as the parameters definition. */ public ClassRef toInternalReference() { List<TypeRef> arguments = new ArrayList<TypeRef>(); for (TypeParamDef parameter : parameters) { arguments.add(parameter.toReference()); } return new ClassRefBuilder() .withDefinition(this) .withArguments(arguments) .withAttributes(getAttributes()) .build(); }
private void visitClassRefBuilder(ClassRefBuilder builder) { builder.withFullyQualifiedName(builder.getFullyQualifiedName().replace(target, replacement)); if (builder.getDefinition() != null && builder.getDefinition().getPackageName() != null && builder.getDefinition().getPackageName().equals(target)) { builder.editDefinition().withPackageName(replacement).endDefinition(); } List<TypeRef> updatedArguments = new ArrayList<TypeRef>(); for (TypeRef arg : builder.getArguments()) { if (arg instanceof ClassRef && ((ClassRef) arg).getDefinition().getPackageName().equals(target)) { updatedArguments.add(new ClassRefBuilder((ClassRef) arg).editDefinition().withPackageName(replacement).endDefinition().build()); } else { updatedArguments.add(arg); } } builder.withArguments(updatedArguments); }
.withArguments(arguments) .build(); } else if (Object.class.equals(item)) {
public ClassRefBuilder(ClassRef instance, Boolean validationEnabled) { this.fluent = this; this.withDefinition(instance.getDefinition()); this.withFullyQualifiedName(instance.getFullyQualifiedName()); this.withDimensions(instance.getDimensions()); this.withArguments(instance.getArguments()); this.withAttributes(instance.getAttributes()); this.validationEnabled = validationEnabled; }
public ClassRef apply(TypeRef item) { TypeRef baseType = TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF).apply(item); if (baseType instanceof ClassRef) { baseType = new ClassRefBuilder((ClassRef)baseType).withArguments().build(); } WildcardRef wildcardRef = new WildcardRefBuilder().addToBounds(baseType).build(); return BuilderContextManager.getContext().getVisitableBuilderInterface().toReference(wildcardRef, Q); } };
.withPackageName(typeDef.getPackageName()) .endDefinition() .withArguments(superClassParameters) .build();
.withPackageName(typeDef.getPackageName()) .endDefinition() .withArguments(superClassParameters) .build();
.withName(boundName) .endDefinition() .withArguments(arguments) .build();
.addToAttributes(ALSO_IMPORT, Arrays.asList(targetType, mapRef)); } else if (isOptional) { final ClassRef ref = new ClassRefBuilder(Optionals.OPTIONAL.toReference()).withArguments(java.util.Collections.EMPTY_LIST).build(); builder.addToAttributes(INIT, "Optional.empty()") .addToAttributes(INIT_FUNCTION, new Construct(Optionals.OPTIONAL, targetType, "of"))
.withArguments(descendantRef) .build();