/** * Creates a {@link ClassRef} without bounds. */ public ClassRef toUnboundedReference() { return new ClassRefBuilder() .withDefinition(this) .withArguments(new TypeRef[0]) .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); }
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); } };
public ClassRef withDimensions(int dimensions) { return new ClassRefBuilder(this).withDimensions(dimensions).build(); }
public ClassRefBuilder edit() { return new ClassRefBuilder(this); }
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); } };
ClassRef superClassFluent = new ClassRefBuilder() .withNewDefinition() .withName(typeDef.getName() + "Fluent") .withPackageName(typeDef.getPackageName()) .endDefinition() .withArguments(superClassParameters) .build();
private void visitPropertyBuilder(PropertyBuilder builder) { if (builder.getTypeRef() instanceof ClassRef) { ClassRefBuilder classRefBuilder = new ClassRefBuilder((ClassRef) builder.getTypeRef()); if (classRefBuilder.getDefinition() != null && classRefBuilder.getDefinition().getPackageName() != null && classRefBuilder.getDefinition().getPackageName().equals(target)) { classRefBuilder.editDefinition().withPackageName(replacement).endDefinition(); } builder.withTypeRef(classRefBuilder.accept(this).build()); } }
public Set<ClassRef> apply(Set<ClassRef> source) { Set<ClassRef> result = new LinkedHashSet<ClassRef>(source); Set<TypeRef> typeArguments = findTypeArguments(source); for (TypeRef type : typeArguments) { Set<ClassRef> intermediate = new LinkedHashSet<ClassRef>(); for (ClassRef clazz : result) { intermediate.add(new ClassRefBuilder(clazz).accept(new TypeArgumentReplace(type, Generics.MAP.apply(type).toReference())).build()); } result = new LinkedHashSet<ClassRef>(intermediate); } return result; } };
public Set<ClassRef> apply(Node node) { Set<ClassRef> imports = new LinkedHashSet<ClassRef>(); if (node instanceof NamedNode) { String name = ((NamedNode)node).getName(); Node current = node; while (!(current instanceof CompilationUnit)) { current = current.getParentNode(); } CompilationUnit compilationUnit = (CompilationUnit) current; for (ImportDeclaration importDecl : compilationUnit.getImports()) { String className = null; String packageName = null; NameExpr importExpr = importDecl.getName(); if (importExpr instanceof QualifiedNameExpr) { QualifiedNameExpr qualifiedNameExpr = (QualifiedNameExpr) importExpr; className = qualifiedNameExpr.getName(); packageName = qualifiedNameExpr.getQualifier().toString(); } else if (importDecl.getName().getName().endsWith(SEPARATOR + name)) { String importName = importDecl.getName().getName(); packageName = importName.substring(0, importName.length() - name.length() -1); } if (className != null && !className.isEmpty()) { imports.add(new ClassRefBuilder().withNewDefinition().withName(className).withPackageName(packageName).and().build()); } } } return imports; } };
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 TypeRef visitError(ErrorType t, Integer dimension) { return new ClassRefBuilder().withDefinition(new TypeDefElementVisitor().visit(t.asElement()).build()).build(); }
public ClassRef buildFirstImplementsList(){ return this.implementsList.get(0).build(); }
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();
public ClassRefNested<A> editOrNewClassRef(){ return withNewClassRefLike(getClassRef() != null ? getClassRef(): new ClassRefBuilder().build()); }
public void visit(ClassRefBuilder builder) { for (TypeRef argument : builder.getArguments()) { if (argument instanceof TypeParamRef) { collection.add((TypeParamRef) argument); } } } }
public A withClassRefTypeRef(ClassRef classRefTypeRef){ _visitables.remove(this.typeRef); if (classRefTypeRef!=null){ this.typeRef= new ClassRefBuilder(classRefTypeRef); _visitables.add(this.typeRef);} return (A) this; }
public TypeRef apply(TypeRef item) { if (item instanceof PrimitiveRef) { return new PrimitiveRefBuilder((PrimitiveRef) item).withDimensions(0).build(); } else if (item instanceof ClassRef) { return new ClassRefBuilder((ClassRef) item).withDimensions(0).build(); } else if (item instanceof TypeParamRef) { return new TypeParamRefBuilder((TypeParamRef) item).withDimensions(0).build(); } else { return item; } } };
ClassRef descendantRef = new ClassRefBuilder(descendant.toInternalReference()) .build(); ClassRef collectionType = new ClassRefBuilder((ClassRef)baseType) .withArguments(descendantRef) .build(); ClassRef candidate = (ClassRef) baseType; for (TypeDef descendant : BUILDABLE_DECENDANTS.apply(candidate.getDefinition())) { ClassRef descendantRef = new ClassRefBuilder(descendant.toInternalReference()) .build();
superClassParameters.add(nestedInterfaceRef); ClassRef superClassFluent = new ClassRefBuilder() .withNewDefinition() .withName(typeDef.getName() + "FluentImpl") .withPackageName(typeDef.getPackageName()) .endDefinition() .withArguments(superClassParameters) .build();