public void cacheType(final String typeFilePath, final ClassOrInterfaceTypeDetails cid) { Validate.notBlank(typeFilePath, "Module name required"); Validate.notNull(cid, "Type details required"); midToTypeDetailsMap.put(cid.getDeclaredByMetadataId(), cid); typeFilePathToMidMap.put(typeFilePath, cid.getDeclaredByMetadataId()); typeIdentifierToFilePathMap.put(cid.getDeclaredByMetadataId(), typeFilePath); types.add(cid.getName()); final String fullyQualifiedTypeName = cid.getName().getFullyQualifiedTypeName(); final String simpleTypeName = cid.getName().getSimpleTypeName(); typeNameToMidMap.put(fullyQualifiedTypeName, cid.getDeclaredByMetadataId()); if (!simpleTypeNameTypesMap.containsKey(simpleTypeName)) { simpleTypeNameTypesMap.put(simpleTypeName, new HashSet<String>()); } simpleTypeNameTypesMap.get(simpleTypeName).add(fullyQualifiedTypeName); }
public void removeItdTypeDetails(final String itdTypeDetailsId) { if (StringUtils.isBlank(itdTypeDetailsId)) { return; } final String type = itdIdToTypeMap.get(itdTypeDetailsId); if (type != null) { final Map<String, MemberHoldingTypeDetails> typeDetailsHashMap = typeMap.get(type); if (typeDetailsHashMap != null) { typeDetailsHashMap.remove(itdTypeDetailsId); } updateChanges(new JavaType(type), true); } }
/** * Returns the accessor name for the given field name and field type. * * @param fieldName the field name used to determine the accessor name * @param fieldType the field type * @return the accessor method name */ public static JavaSymbolName getAccessorMethodName(final JavaSymbolName fieldName, final JavaType fieldType) { Validate.notNull(fieldName, "Field name required"); Validate.notNull(fieldType, "Field type required"); final String capitalizedFieldName = StringUtils.capitalize(fieldName.getSymbolName()); return fieldType.equals(JavaType.BOOLEAN_PRIMITIVE) ? new JavaSymbolName("is" + capitalizedFieldName) : new JavaSymbolName("get" + capitalizedFieldName); }
/** * Returns the non-primitive type that represent this type if it is primitive. Otherwise, returns itself. * @return */ public JavaType toObjectType() { if (isPrimitive()) { return new JavaType(getFullyQualifiedTypeName(), getArray(), DataType.TYPE, getArgName(), getParameters(), getModule()); } return this; }
/** Return {@link JavaType} which is a Widcard of generics with "supper" * value. * * By exampe: JavaType.listOf(JavaType.wilcardSupper(JavaType.NUMBER)) generates List<? supper Number> * * @param supperOf * @return */ public static JavaType wilcardSupper(final JavaType supperOf) { return new JavaType(supperOf.getFullyQualifiedTypeName(), 0, DataType.TYPE, JavaType.WILDCARD_SUPER_ARG, null); }
public JavaType withoutParameters() { return new JavaType(getFullyQualifiedTypeName(), getArray(), DataType.TYPE, getArgName(), null, getModule()); } }
@Override public boolean isNullRequiredVisibleForFieldNumber(ShellContext shellContext) { // Check if `notNull`is specified String notNullParam = shellContext.getParameters().get("notNull"); if (notNullParam != null) { return false; } // Check if type is primitive String typeValue = shellContext.getParameters().get("type"); if (StringUtils.isNotBlank(typeValue)) { JavaType numberType = getJavaTypeConverter().convertFromText(typeValue, JavaType.class, "java-number"); if (numberType.isPrimitive()) { return false; } } return true; }
private JavaType filterControllerByPackageAndPrefix( Collection<ClassOrInterfaceTypeDetails> itemControllers, JavaPackage controllerPackage, String pathPrefix) { for (ClassOrInterfaceTypeDetails controller : itemControllers) { ControllerAnnotationValues values = new ControllerAnnotationValues(controller); if (controllerPackage.equals(controller.getType().getPackage()) && (StringUtils.isBlank(pathPrefix) && StringUtils.isBlank(values.getPathPrefix()) || StringUtils .equals(pathPrefix, values.getPathPrefix()))) { return controller.getType(); } } return null; }
private String getPlural(final PluralAnnotationValues pluralAnnotation) { if (StringUtils.isNotBlank(pluralAnnotation.getValue())) { return pluralAnnotation.getValue(); } return getInflectorPlural(destination.getSimpleTypeName(), Locale.ENGLISH); }
parameterTypes.add(AnnotatedJavaType.convertFromJavaType(entity)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(entity.getSimpleTypeName()))); Validate.notNull(childEntityMetadata, "Can't get entity metadata for %s entity generating %s", relationInfo.childType, aspectName); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(childEntityMetadata.getCurrentIndentifierField().getFieldType()))); parameterNames.add(entityRemoveMethod.getParameterNames().get(0)); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, entity, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata
private boolean isExceptionAnnotatedWithResponseStatus(JavaType exception) { ClassOrInterfaceTypeDetails exceptionCid = typeLocationService.getTypeDetails(exception); Validate.notNull(exceptionCid, String.format("Can't found class: %s", exception.getFullyQualifiedTypeName())); AnnotationMetadata annotation = exceptionCid.getAnnotation(SpringJavaType.RESPONSE_STATUS); if (annotation == null) { return false; } return true; }
public EmbeddedIdHolder(final FieldMetadata embeddedIdField, final List<FieldMetadata> idFields) { Validate.notNull(embeddedIdField, "Identifier type required"); Validate.notNull(idFields, "Fields for %s required", embeddedIdField.getFieldType() .getFullyQualifiedTypeName()); this.embeddedIdField = embeddedIdField; this.idFields = idFields; }
/** * This method returns field to included on service for a Service or * Repository * * @param service * @return */ private FieldMetadata getFieldFor(JavaType type) { // Generating service field name final JavaSymbolName fieldName = new JavaSymbolName(StringUtils.uncapitalize(type.getSimpleTypeName())); FieldMetadata currentField = governorTypeDetails.getField(fieldName); if (currentField != null) { Validate.isTrue(currentField.getFieldType().equals(type), "Field %s already in %s but type not match: expected %s", currentField.getFieldName(), governorTypeDetails.getType(), type); return currentField; } return new FieldMetadataBuilder(getId(), Modifier.PRIVATE, new ArrayList<AnnotationMetadataBuilder>(), fieldName, type).build(); }
public void setType(final JavaType javaType) { Validate.notNull(javaType, "JavaType required"); if (javaType.getPackage().getFullyQualifiedPackageName().startsWith("java.")) { return; } module = null; this.javaType = javaType; javaPackage = javaType.getPackage(); setPromptPath(javaType.getFullyQualifiedTypeName()); }
public ClassOrInterfaceTypeDetails getDeclaredInnerType(final JavaType typeName) { Validate.notNull(typeName, "Name of inner type required"); for (final ClassOrInterfaceTypeDetails cid : getDeclaredInnerTypes()) { if (cid.getName().getSimpleTypeName().equals(typeName.getSimpleTypeName())) { return cid; } } return null; }
/** * This method checks if the provided type is enum or not * * @param fieldType * @return */ private boolean isEnumType(FieldMetadata field) { Validate.notNull(field, "Java type required"); final JavaType fieldType = field.getFieldType(); if (fieldType.isPrimitive()) { return false; } if (STANDAR_TYPES.contains(fieldType) || DATE_TIME_TYPES.contains(fieldType)) { return false; } if (field.getAnnotation(JpaJavaType.ENUMERATED) != null) { return true; } final ClassOrInterfaceTypeDetails javaTypeDetails = getTypeLocationService().getTypeDetails(fieldType); return javaTypeDetails != null && javaTypeDetails.getPhysicalTypeCategory().equals(PhysicalTypeCategory.ENUMERATION); }
public static void verifyReservedSqlKeywordsNotPresent(final JavaType javaType) { Validate.notNull(javaType, "Java type required"); if (RESERVED_SQL_KEYWORDS.contains(javaType.getSimpleTypeName().toLowerCase())) { throw new IllegalStateException("Reserved SQL keyword '" + javaType.getSimpleTypeName() + "' is not permitted as simple type name"); } }
public JavaType getItdJavaType(final ItdMetadataProvider metadataProvider) { Validate.notNull(metadataProvider, "Metadata provider required"); return new JavaType(PhysicalTypeIdentifier.getJavaType(getId()).getFullyQualifiedTypeName() + "_Roo_" + metadataProvider.getItdUniquenessFilenameSuffix()); }
public void setTypeNotVerified(JavaType javaType) { Validate.notNull(javaType, "JavaType required"); if (javaType.getPackage().getFullyQualifiedPackageName().startsWith("java.")) { return; } registerListener(); this.javaTypeNotVerified = javaType; javaPackageNotVerified = javaType.getPackage(); this.isVerified = false; module = null; }