@Override public String toString() { return getNameIncludingTypeParameters(); }
/** * Obtains the name of this type, including type parameters. It will be * formatted in a manner compatible with non-static use. No type name import * resolution will take place. This is a side-effect free method. * * @return the type name, including parameters, as legal Java code (never * null or empty) */ public String getNameIncludingTypeParameters() { return getNameIncludingTypeParameters(false, null, new HashMap<String, String>()); }
/** * Obtains the name of this type, including type parameters. It will be * formatted in a manner compatible with either static or non-static usage, * as per the passed argument. Type names will attempt to be resolved (and * automatically registered) using the passed resolver. This method will * have side-effects on the passed resolver. * * @param staticForm true if the output should be compatible with static use * @param resolver the resolver to use (may be null in which case no import * resolution will occur) * @return the type name, including parameters, as legal Java code (never * null or empty) */ public String getNameIncludingTypeParameters(final boolean staticForm, final ImportRegistrationResolver resolver) { return getNameIncludingTypeParameters(staticForm, resolver, new HashMap<String, String>()); }
@Override public final String toString() { final StringBuilder sb = new StringBuilder(); for (final AnnotationMetadata annotation : annotations) { sb.append(AnnotationMetadataUtils.toSourceForm(annotation)); sb.append(" "); } sb.append(javaType.getNameIncludingTypeParameters()); return sb.toString(); } }
@Override public String toString() { return getName() + " -> " + value.getNameIncludingTypeParameters(); } }
/** * Returns String which represents type inside ITD * * Delegates on {@link JavaType#getNameIncludingTypeParameters(boolean, org.springframework.roo.model.ImportRegistrationResolver)} * * @param type * @param asStatic * @return */ protected String getNameOfJavaType(JavaType type, boolean asStatic) { return type.getNameIncludingTypeParameters(asStatic, builder.getImportRegistrationResolver()); } }
/** * Returns the default `hasCode` method return statement * * @return a {@link StringBuilder} */ private static StringBuilder getDefaultHashCodeMethodReturnStatment( EqualsAnnotationValues annotationValues, List<FieldMetadata> locatedFields, ImportRegistrationResolver importRegistrationResolver) { final StringBuilder builder = new StringBuilder(String.format("return new %s()", HASH_CODE_BUILDER.getNameIncludingTypeParameters(false, importRegistrationResolver))); if (annotationValues.isAppendSuper()) { builder.append(".appendSuper(super.hashCode())"); } for (final FieldMetadata field : locatedFields) { builder.append(".append(" + field.getFieldName() + ")"); } builder.append(".toHashCode();"); return builder; }
private void writeImplements(final List<JavaType> implementsTypes) { if (!implementsTypes.isEmpty()) { append(" implements "); for (int i = 0; i < implementsTypes.size(); i++) { final JavaType implementsType = implementsTypes.get(i); if (resolver.isFullyQualifiedFormRequiredAfterAutoImport(implementsType)) { append(implementsType.getNameIncludingTypeParameters()); } else { append(implementsType.getNameIncludingTypeParameters(false, resolver)); } if (i != implementsTypes.size() - 1) { append(", "); } else { append(" "); } } } }
private void writeExtends(final ClassOrInterfaceTypeDetails innerType) { if (!innerType.getExtendsTypes().isEmpty()) { append(" extends "); // There should only be one extends type for inner classes final JavaType extendsType = innerType.getExtendsTypes().get(0); if (resolver.isFullyQualifiedFormRequiredAfterAutoImport(extendsType)) { append(extendsType.getNameIncludingTypeParameters()); } else { append(extendsType.getNameIncludingTypeParameters(false, resolver)); } append(" "); } }
private void writeParameters(final List<AnnotatedJavaType> parameterTypes, final List<JavaSymbolName> parameterNames) { for (int i = 0; i < parameterTypes.size(); i++) { final AnnotatedJavaType paramType = parameterTypes.get(i); final JavaSymbolName paramName = parameterNames.get(i); for (final AnnotationMetadata methodParameterAnnotation : paramType.getAnnotations()) { outputAnnotation(methodParameterAnnotation); append(" "); } append(paramType.getJavaType().getNameIncludingTypeParameters(false, resolver)); append(" "); append(paramName.getSymbolName()); if (i < parameterTypes.size() - 1) { append(", "); } } }
aspectNames.add(mAspect.getNameIncludingTypeParameters()); } else { aspectNames.add(mAspect.getNameIncludingTypeParameters(false, resolver));
/** * Builds a method which returns the class of entity JavaType. * * @return MethodMetadataBuilder */ private MethodMetadata getEntityTypeGetterMethod() { List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); MethodMetadata existingMethod = getGovernorMethod(GET_ENTITY_TYPE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // return ENTITY_TYPE.class; bodyBuilder.appendFormalLine("return %s.class;", this.entity.getNameIncludingTypeParameters(false, importResolver)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, GET_ENTITY_TYPE_METHOD_NAME, JavaType.wrapperOf(JavaType.CLASS, this.entity), parameterTypes, parameterNames, bodyBuilder); // Build and return a MethodMetadata instance return methodBuilder.build(); }
private void appendImplementsTypes() { final List<JavaType> implementsTypes = itdTypeDetails.getImplementsTypes(); if (implementsTypes == null || implementsTypes.isEmpty()) { return; } content = true; for (final JavaType extendsType : implementsTypes) { appendIndent(); append("declare parents: "); append(introductionTo.getSimpleTypeName()); append(" implements "); if (resolver.isFullyQualifiedFormRequiredAfterAutoImport(extendsType)) { append(extendsType.getNameIncludingTypeParameters()); } else { append(extendsType.getNameIncludingTypeParameters(false, resolver)); } append(";"); this.newLine(false); this.newLine(); } }
private void appendExtendsTypes() { final List<JavaType> extendsTypes = itdTypeDetails.getExtendsTypes(); if (extendsTypes == null || extendsTypes.isEmpty()) { return; } content = true; for (final JavaType extendsType : extendsTypes) { appendIndent(); append("declare parents: "); append(introductionTo.getSimpleTypeName()); append(" extends "); if (resolver.isFullyQualifiedFormRequiredAfterAutoImport(extendsType)) { append(extendsType.getNameIncludingTypeParameters()); } else { append(extendsType.getNameIncludingTypeParameters(false, resolver)); } append(";"); this.newLine(false); this.newLine(); } }
EQUALS_BUILDER.getNameIncludingTypeParameters(false, importRegistrationResolver))); if (appendSuper) { builder.append(".appendSuper(super.equals(" + OBJECT_NAME + "))");
SpringletsJavaType.SPRINGLETS_GENERIC_VALIDATOR.getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()), entity.getBaseType() .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()), getAccessorMethod(controllerMetadata.getServiceField()).getMethodName()); body.appendFormalLine("binder.addValidators(validator);");
append(" "); append(methodDetails.getMethodMetadata().getReturnType() .getNameIncludingTypeParameters(false, resolver)); append(" "); append(introductionTo.getSimpleTypeName()); for (int i = 0; i < methodDetails.getMethodMetadata().getParameterTypes().size(); i++) { append(methodDetails.getMethodMetadata().getParameterTypes().get(i).getJavaType() .getNameIncludingTypeParameters(false, resolver)); if (i != methodDetails.getMethodMetadata().getParameterTypes().size() - 1) { append(",");
JavaType.OBJECTS.getNameIncludingTypeParameters(false, importRegistrationResolver), typeName, OBJECT_NAME);
private void writeInnerTypeFields(final ClassOrInterfaceTypeDetails innerType) { for (final FieldMetadata field : innerType.getDeclaredFields()) { indent(); this.newLine(false); // Append annotations for (final AnnotationMetadata annotation : field.getAnnotations()) { appendIndent(); outputAnnotation(annotation); this.newLine(false); } appendIndent(); if (field.getModifier() != 0) { append(Modifier.toString(field.getModifier())); append(" "); } append(field.getFieldType().getNameIncludingTypeParameters(false, resolver)); append(" "); append(field.getFieldName().getSymbolName()); // Append initializer, if present if (field.getFieldInitializer() != null) { append(" = "); append(field.getFieldInitializer()); } // Complete the field declaration append(";"); this.newLine(false); indentRemove(); } }
append(introductionTo.getNameIncludingTypeParameters()); append("."); append(innerType.getName().getSimpleTypeName());