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 static Set<ClassRef> extractInterfacesFromType(TypeDef type) { Set<ClassRef> result = new LinkedHashSet<ClassRef>(); if (type.getExtendsList().isEmpty()) { result.add(type.toInternalReference()); } else { for (ClassRef interfaceType : type.getExtendsList()) { result.addAll(extractInterfacesFromClassRef(interfaceType)); } } return result; }
private Map<String, String> getReferenceMapInternal() { Map<String, String> mapping = new HashMap<String, String>(); List<ClassRef> refs = new ArrayList<ClassRef>(); for (TypeDef typeDef : getDefinitions()) { refs.add(typeDef.toInternalReference()); } //It's best to have predictable order, so that we can generate uniform code. Collections.sort(refs, new Comparator<ClassRef>() { @Override public int compare(ClassRef o1, ClassRef o2) { return o1.getFullyQualifiedName().compareTo(o2.getFullyQualifiedName()); } }); for (ClassRef classRef : refs) { String key = classRef.getDefinition().getName(); if (!mapping.containsKey(key)) { mapping.put(key, classRef.getDefinition().getFullyQualifiedName()); } } mapping.putAll(custom); return mapping; }
for (TypeDef alternative : alternatives) { if (!canBeExcluded(alternative, alternatives)) { interfaces.add(alternative.toInternalReference()); terminatingTypes.addAll(getTerminatingTypes(alternative)); interfaces.add(fallback.toInternalReference()); terminatingTypes.addAll(getTerminatingTypes(fallback)); for (TypeParamDef candidate : extractParameters(fallback)) {
public TypeDef apply(TypeDef item) { TypeDef builder = SHALLOW_BUILDER.apply(item); TypeDef fluent = FLUENT_IMPL.apply(item); List<TypeRef> parameters = new ArrayList<TypeRef>(); for (TypeParamDef param : item.getParameters()) { parameters.add(param.toReference()); } parameters.add(builder.toInternalReference()); return new TypeDefBuilder(item) .withKind(Kind.CLASS) .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName(item.getName() + "Builder") .withParameters(item.getParameters()) .withInnerTypes() .withExtendsList(fluent.toReference(parameters)) .withImplementsList(BuilderContextManager.getContext().getVisitableBuilderInterface().toReference(item.toInternalReference(), builder.toInternalReference())) .build(); } };
public ClassRef apply(Node<TypeDef> current) { if (current.getTransitions().isEmpty()) { return current.getItem().toInternalReference(); } else { TypeDef clazz = current.getItem(); : Combine.TYPEREFS.apply(Generify.CLASSREFS.apply(toCombine)).toInternalReference(); toReCombine.add(selfRef); TypeDef reCombinedType = Combine.TYPEREFS.apply(toReCombine); final ClassRef reCombinedRef = reCombinedType.toInternalReference(); ClassRef reCombined = reCombinedType.toInternalReference(); reCombined = Combine.TYPEREFS.apply(toReCombine).toInternalReference(); DslContextManager.getContext().getDefinitionRepository().register(reCombinedType, IS_GENERATED); DslContextManager.getContext().getDefinitionRepository().register(nextClazz.getDefinition(), IS_GENERATED);
public static ClassRef buildableRef(TypeRef typeRef) { ClassRef unwrapped = (ClassRef) TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(typeRef); return isAbstract(unwrapped) || unwrapped.getDefinition().getKind() == Kind.INTERFACE ? TypeAs.VISITABLE_BUILDER.apply(unwrapped) : TypeAs.BUILDER.apply(unwrapped.getDefinition()).toInternalReference(); }
public TypeDef apply(TypeDef item) { List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(); for (TypeParamDef generic : item.getParameters()) { parameters.add(generic); } return new TypeDefBuilder(item) .withKind(Kind.CLASS) .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName("Editable" + item.getName()) .withParameters(parameters) .withExtendsList(item.toInternalReference()) .withImplementsList(BuilderContextManager.getContext().getEditableInterface().toReference(SHALLOW_BUILDER.apply(item).toInternalReference())) .withInnerTypes() .withProperties() .withMethods() .withConstructors() .build(); } };
if (returnType instanceof ClassRef) { TypeDef toUnwrap = ((ClassRef)returnType).getDefinition(); methods.add(new MethodBuilder(m).withReturnType(Generics.UNWRAP.apply(toUnwrap).toInternalReference()).build()); } else if (returnType.getAttributes().containsKey(ORIGINAL_REF)) { methods.add(new MethodBuilder(m).withReturnType((TypeRef) returnType.getAttributes().get(ORIGINAL_REF)).build());
public TypeDef apply(TypeDef item) { BuilderContext ctx = BuilderContextManager.getContext(); TypeDef fluent = SHALLOW_FLUENT.apply(item); List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(item.getParameters()); List<TypeRef> superClassParameters = new ArrayList<TypeRef>(); TypeParamDef nextParameter = getNextGeneric(item, parameters); ClassRef builableSuperClassRef = findBuildableSuperClassRef(item); if (builableSuperClassRef != null) { superClassParameters.addAll(builableSuperClassRef.getArguments()); } TypeParamDef parameterFluent = new TypeParamDefBuilder(nextParameter).addToBounds(fluent.toInternalReference()).build(); parameters.add(parameterFluent); superClassParameters.add(parameterFluent.toReference()); TypeDef buildableSuperClass = findBuildableSuperClass(item); TypeDef superClass = buildableSuperClass != null ? FLUENT_IMPL.apply(buildableSuperClass) : ctx.getBaseFluentClass(); return new TypeDefBuilder(item) .withKind(Kind.CLASS) .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName(item.getName() + "FluentImpl") .withPackageName(item.getPackageName()) .withParameters(parameters) .withExtendsList(superClass.toReference(superClassParameters)) .withImplementsList(SHALLOW_FLUENT.apply(item).toInternalReference()) .withInnerTypes() .build(); }
alsoImport.add(builder.toInternalReference());
public TypeDef apply(TypeDef item) { BuilderContext ctx = BuilderContextManager.getContext(); TypeDef fluent = SHALLOW_FLUENT.apply(item); List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(item.getParameters()); List<TypeRef> superClassParameters = new ArrayList<TypeRef>(); TypeParamDef nextParameter = getNextGeneric(item, parameters); ClassRef builableSuperClassRef = findBuildableSuperClassRef(item); TypeDef buildableSuperClass = findBuildableSuperClass(item); if (builableSuperClassRef != null) { superClassParameters.addAll(builableSuperClassRef.getArguments()); } TypeParamDef parameterFluent = new TypeParamDefBuilder(nextParameter).addToBounds(fluent.toInternalReference()).build(); parameters.add(parameterFluent); superClassParameters.add(parameterFluent.toReference()); TypeDef superClass = buildableSuperClass != null ? SHALLOW_FLUENT.apply(buildableSuperClass) : ctx.getFluentInterface(); return new TypeDefBuilder(item) .withKind(Kind.INTERFACE) .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName(item.getName() + "Fluent") .withPackageName(item.getPackageName()) .withParameters(parameters) .withExtendsList(superClass.toReference(superClassParameters)) .withImplementsList() .withInnerTypes() .build(); } };
refs.add(typeDef.toInternalReference());
.withReturnType(builderType.toInternalReference()) .withName("edit") .withNewBlock()
baseType = propertyTypeDef.toInternalReference();
baseType = propertyTypeDef.toInternalReference();
baseType = propertyTypeDef.toInternalReference();
String ownPrefix = isCollection ? "addNew" : "withNew"; ownPrefix += BuilderUtils.fullyQualifiedNameDiff(baseType.toInternalReference(), originTypeDef); String ownName = ownPrefix + (isCollection ? Singularize.FUNCTION.apply(property.getNameCapitalized())
baseType = propertyTypeDef.toInternalReference();
ClassRef unwrapped = (ClassRef) TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(typeRef); ClassRef classRef = (ClassRef) typeRef; ClassRef builderType = isAbstract(unwrapped) || unwrapped.getDefinition().getKind() == Kind.INTERFACE ? TypeAs.VISITABLE_BUILDER.apply(unwrapped) : TypeAs.BUILDER.apply(unwrapped.getDefinition()).toInternalReference();