public TypeDefBuilder visitPackage(PackageElement e, Void aVoid) { return builder.withPackageName(e.getQualifiedName().toString()); }
public TypeDef apply(Class item) { if (Object.class.equals(item)) { return TypeDef.OBJECT; } Kind kind = KIND.apply(item); return new TypeDefBuilder() .withKind(kind) .withName(item.getSimpleName()) .withPackageName(item.getPackage() != null ? item.getPackage().getName() : null) .withModifiers(item.getModifiers()) .withParameters() .build(); } };
private static List<TypeDef> setOuterType(List<TypeDef> types, TypeDef outer) { List<TypeDef> updated = new ArrayList<TypeDef>(); for (TypeDef typeDef : types) { if (outer.equals(typeDef.getOuterType())) { updated.add(typeDef); } else { updated.add(new TypeDefBuilder(typeDef).withOuterType(outer).withPackageName(outer.getPackageName()).build()); } } return updated; }
private void visitTypeDefBuilder(TypeDefBuilder builder) { if (target.equals(builder.getPackageName())) { builder.withPackageName(replacement); } if (builder.getAttributes().containsKey(TypeDef.ALSO_IMPORT)) { Set<ClassRef> updatedImports = new LinkedHashSet<ClassRef>(); for (ClassRef classRef : (Set<ClassRef>) builder.getAttributes().get(TypeDef.ALSO_IMPORT)) { if (target.equals(classRef.getDefinition().getPackageName())) { updatedImports.add(new ClassRefBuilder(classRef).accept(this).build()); } else { updatedImports.add(classRef); } } builder.getAttributes().put(TypeDef.ALSO_IMPORT, updatedImports); } }
public TypeDefBuilder visit(Element e) { if (e instanceof TypeElement) { return new TypeDefBuilder(ElementTo.TYPEDEF.apply((TypeElement) e)); } String name = e.getSimpleName().toString(); builder.withName(name); if (e.getKind() == ElementKind.INTERFACE) { builder.withKind(Kind.INTERFACE); } else if (e.getKind() == ElementKind.ENUM) { builder.withKind(Kind.ENUM); }else if (e.getKind() == ElementKind.ANNOTATION_TYPE) { builder.withKind(Kind.ANNOTATION); } else { builder.withKind(Kind.CLASS); } if (e.getEnclosingElement() instanceof PackageElement) { String packageName = e.getEnclosingElement().toString(); builder.withPackageName(packageName); } return builder; }
.withKind(kind) .withName(item.getSimpleName()) .withPackageName(item.getPackage() != null ? item.getPackage().getName() : null) .withModifiers(item.getModifiers()) .withParameters(parameters)
.withPackageName(packageName) .withName(className) .withImplementsList(interfaces)
public TypeDef apply(TypeElement classElement) { List<ClassRef> extendsList = new ArrayList<ClassRef>(); //Check SuperClass Kind kind = Kind.CLASS; if (classElement.getKind() == ElementKind.INTERFACE) { kind = Kind.INTERFACE; } else if (classElement.getKind() == ElementKind.CLASS) { kind = Kind.CLASS; extendsList.add(TypeDef.OBJECT_REF); } else if (classElement.getKind() == ElementKind.ANNOTATION_TYPE) { kind = Kind.ANNOTATION; } Set<Method> allMethods = new LinkedHashSet<Method>(); for (ExecutableElement method : ElementFilter.methodsIn(classElement.getEnclosedElements())) { } return new TypeDefBuilder() .withKind(kind) .withModifiers(TypeUtils.modifiersToInt(classElement.getModifiers())) .withPackageName(getPackageName(classElement)) .withName(getClassName(classElement)) .withExtendsList(extendsList) .addAllToMethods(allMethods) .withOuterType(classElement.getEnclosingElement() instanceof TypeElement ? SHALLOW_TYPEDEF.apply((TypeElement) classElement.getEnclosingElement()) : null) .build(); } };
.withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName(className) .withPackageName(packageName) .withExtendsList(interfaces) .withParameters(parameters.toArray(new TypeParamDef[parameters.size()]))
.withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC)) .withName(className) .withPackageName(packageName) .withExtendsList(interfaces) .withParameters(parameters.toArray(new TypeParamDef[parameters.size()]))
public TypeRef apply(TypeRef type) { if (type instanceof ClassRef) { ClassRef classRef = (ClassRef) type; if (TypeUtils.isOptional(classRef)) { return classRef.getArguments().get(0); } if (TypeUtils.isOptionalInt(classRef)) { return new TypeDefBuilder().withPackageName("java.lang").withName("Integer").build().toReference(); } if (TypeUtils.isOptionalLong(classRef)) { return new TypeDefBuilder().withPackageName("java.lang").withName("Long").build().toReference(); } if (TypeUtils.isOptionalDouble(classRef)) { return new TypeDefBuilder().withPackageName("java.lang").withName("Double").build().toReference(); } } return type; } };
.withPackageName("changeme") .withName(item.getName()) .withKind(item.isInterface() ? Kind.INTERFACE : Kind.CLASS)
public TypeDef apply(Property property) { TypeDef originTypeDef = property.getAttribute(Constants.ORIGIN_TYPEDEF); TypeRef typeRef = TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(property.getTypeRef()); TypeDef typeDef = BuilderContextManager.getContext().getDefinitionRepository().getDefinition(typeRef); if (typeDef == null) { if (typeRef instanceof ClassRef) { typeDef = ((ClassRef)typeRef).getDefinition(); } else { throw new IllegalStateException("Could not find definition from property: ["+property+"] neither in the repo nor via the object tree."); } } TypeDef outerInterface = property.getAttribute(OUTER_INTERFACE); List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(); for (TypeParamDef generic : typeDef.getParameters()) { parameters.add(generic); } parameters.add(N); return new TypeDefBuilder(typeDef) .withPackageName(outerInterface.getPackageName()) .withName(BuilderUtils.fullyQualifiedNameDiff(property.getTypeRef(), originTypeDef) + property.getNameCapitalized() + "Nested") .withParameters(parameters) .build(); } };
public TypeDef getInlineableInterface(Inline inline) { return new TypeDefBuilder(inlineableBase) .withKind(Kind.INTERFACE) .withPackageName(builderPackage) .withName(inline.prefix() + (!inline.name().isEmpty() ? inline.name() : INLINEABLE.getName()) + inline.suffix()) .withParameters(INLINEABLE.getParameters()) .addNewMethod() .withReturnType(TypeUtils.newTypeParamRef("T")) .withName(inline.value()) .and() .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); 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(); } };
.withPackageName(outerInterface.getPackageName()) .withParameters(parameters) .withOuterType(outerInterface)
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(); }
result.add(new TypeDefBuilder(clazz) .withKind(Kind.INTERFACE) .withPackageName(scopeInterface.getDefinition().getPackageName()) .withName(scopeInterface.getDefinition().getName() + SCOPE_SUFFIX) .withExtendsList(scopeInterface)
.withPackageName(outerClass.getPackageName()) .withName(shallowNestedType.getName() + "Impl") .withOuterType(outerClass)
public TypeDefBuilder(TypeDef instance,Boolean validationEnabled){ this.fluent = this; this.withKind(instance.getKind()); this.withPackageName(instance.getPackageName()); this.withName(instance.getName()); this.withComments(instance.getComments()); this.withAnnotations(instance.getAnnotations()); this.withExtendsList(instance.getExtendsList()); this.withImplementsList(instance.getImplementsList()); this.withParameters(instance.getParameters()); this.withProperties(instance.getProperties()); this.withConstructors(instance.getConstructors()); this.withMethods(instance.getMethods()); this.withOuterType(instance.getOuterType()); this.withInnerTypes(instance.getInnerTypes()); this.withModifiers(instance.getModifiers()); this.withAttributes(instance.getAttributes()); this.validationEnabled = validationEnabled; }