@Override protected ItdTypeDetailsProvidingMetadataItem getMetadata( final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) { // Acquire bean info (we need getters details, specifically) final JavaType javaType = JsonMetadata.getJavaType(metadataIdentificationString); final LogicalPath path = JsonMetadata.getPath(metadataIdentificationString); // We need to parse the annotation, if it is not present we will simply // get the default annotation values final JsonAnnotationValues annotationValues = new JsonAnnotationValues(governorPhysicalTypeMetadata); String plural = javaType.getSimpleTypeName() + "s"; final PluralMetadata pluralMetadata = (PluralMetadata) getMetadataService().get(PluralMetadata.createIdentifier(javaType, path)); if (pluralMetadata != null) { plural = pluralMetadata.getPlural(); } return new JsonMetadata( metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, plural, annotationValues); }
private MethodMetadataBuilder getCreateMethod(String declaredById, JavaType targetType) { InvocableMemberBodyBuilder invocableMemberBodyBuilder = InvocableMemberBodyBuilder.getInstance(); invocableMemberBodyBuilder.append("return new " + targetType.getSimpleTypeName() + "();"); MethodMetadataBuilder createMethodBuilder = new MethodMetadataBuilder( declaredById, Modifier.PUBLIC, new JavaSymbolName("create"), targetType, invocableMemberBodyBuilder); JavaType wildEntityType = new JavaType( targetType.getFullyQualifiedTypeName(), 0, DataType.VARIABLE, JavaType.WILDCARD_EXTENDS, null); JavaType classParameterType = new JavaType( JavaType.CLASS.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Arrays.asList(wildEntityType)); createMethodBuilder.addParameter("clazz", classParameterType); return createMethodBuilder; }
public static JavaType convertPrimitiveType(final JavaType type, final boolean convertVoid) { if (!convertVoid && JavaType.VOID_PRIMITIVE.equals(type)) { return type; } if (type != null && type.isPrimitive()) { return new JavaType(type.getFullyQualifiedTypeName()); } return type; }
/** @return the find all method (may return null) */ private MethodMetadata getFindAllMethod() { if ("".equals(crudAnnotationValues.getFindAllMethod())) { return null; } // Method definition to find or build final JavaSymbolName methodName = new JavaSymbolName(crudAnnotationValues.getFindAllMethod() + plural); final JavaType[] parameterTypes = {}; final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); final JavaType returnType = new JavaType( LIST.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Arrays.asList(destination)); // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(returnType), "Method '" + methodName + "' on '" + destination + "' must return '" + returnType.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); if (isGaeEnabled) { addTransactionalAnnotation(annotations); } final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "return " + ENTITY_MANAGER_METHOD_NAME + "().createQuery(\"SELECT o FROM " + entityName + " o\", " + destination.getSimpleTypeName() + ".class).getResultList();"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
private void maybeAddImport( final TemplateDataDictionary dataDictionary, final Set<String> importSet, final JavaType type) { if (!importSet.contains(type.getFullyQualifiedTypeName())) { addImport(dataDictionary, type.getFullyQualifiedTypeName()); importSet.add(type.getFullyQualifiedTypeName()); } }
public String getCollectionRenderer() { JavaType arg = OBJECT; if (type.getParameters().size() > 0) { arg = type.getParameters().get(0); } return GwtPath.SCAFFOLD_PLACE.packageName(topLevelPackage) + ".CollectionRenderer.of(" + new GwtProxyProperty(topLevelPackage, ptmd, arg).getRenderer() + ")"; }
/** * Sets up the mock {@link RepositoryJpaLocator} and {@link PersistenceMemberLocator} to return a * mock repository for our test entity. */ private void setUpMockRepository() { final ClassOrInterfaceTypeDetails mockRepositoryDetails = mock(ClassOrInterfaceTypeDetails.class); final FieldMetadata mockFieldMetadata = mock(FieldMetadata.class); final JavaType mockRepositoryType = mock(JavaType.class); when(mockRepositoryType.getSimpleTypeName()).thenReturn("ClinicRepo"); when(mockIdType.getFullyQualifiedTypeName()).thenReturn(Long.class.getName()); when(mockRepositoryDetails.getName()).thenReturn(mockRepositoryType); when(mockFieldMetadata.getFieldType()).thenReturn(mockIdType); when(mockRepositoryLocator.getRepositories(mockTargetEntity)) .thenReturn(Arrays.asList(mockRepositoryDetails)); }
private String getSetEditor() { String typeName = OBJECT.getFullyQualifiedTypeName(); if (type.getParameters().size() > 0) { typeName = type.getParameters().get(0).getSimpleTypeName(); } if (typeName.endsWith(GwtType.PROXY.getSuffix())) { typeName = typeName.substring(0, typeName.length() - GwtType.PROXY.getSuffix().length()); } return typeName + (type.getSimpleTypeName().equals("Set") ? GwtType.SET_EDITOR.getSuffix() : GwtType.LIST_EDITOR.getSuffix()); }
public String getSetValuePickerMethod() { return "\tpublic void " + getSetValuePickerMethodName() + "(Collection<" + (isCollection() ? type.getParameters().get(0).getSimpleTypeName() : type.getSimpleTypeName()) + "> values) {\n" + "\t\t" + getName() + ".setAcceptableValues(values);\n" + "\t}\n"; }
/** * Asserts that the given preferred mapping provided by the user gives rise to the expected folder * name and mapping to use in the annotation * * @param preferredMapping * @param expectedFolder * @param expectedMapping */ private void assertFolderAndMapping( final String preferredMapping, final String expectedFolder, final String expectedMapping) { // Set up final JavaType mockController = mock(JavaType.class); when(mockController.getSimpleTypeName()).thenReturn("FooController"); // Invoke final Pair<String, String> pair = JspOperationsImpl.getFolderAndMapping(preferredMapping, mockController); // Check assertEquals(expectedFolder, pair.getKey()); assertEquals(expectedMapping, pair.getValue()); }
public String getBinder() { if (type.equals(JavaType.DOUBLE_OBJECT)) { return "g:DoubleBox"; } if (type.equals(LONG_OBJECT)) { return "g:LongBox"; } if (type.equals(JavaType.INT_OBJECT)) { return "g:IntegerBox"; } if (type.equals(JavaType.FLOAT_OBJECT)) { return "r:FloatBox"; } if (type.equals(JavaType.BYTE_OBJECT)) { return "r:ByteBox"; } if (type.equals(JavaType.SHORT_OBJECT)) { return "r:ShortBox"; } if (type.equals(JavaType.CHAR_OBJECT)) { return "r:CharBox"; } if (type.equals(BIG_DECIMAL)) { return "r:BigDecimalBox"; } return isCollection() ? "a:" + getSetEditor() : isDate() ? "d:DateBox" : isBoolean() ? "g:CheckBox" : isString() ? "g:TextBox" : "g:ValueListBox"; }
public void injectEmailTemplate( final JavaType targetType, final JavaSymbolName fieldName, final boolean async) { Assert.notNull(targetType, "Java type required"); Assert.notNull(fieldName, "Field name required"); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(AUTOWIRED)); // Obtain the physical type and its mutable class details final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(targetType); ClassOrInterfaceTypeDetails existing = typeLocationService.findClassOrInterface(targetType); if (existing == null) { log.warning( "Aborting: Unable to find metadata for target type '" + targetType.getFullyQualifiedTypeName() + "'"); return; } final ClassOrInterfaceTypeDetailsBuilder classOrInterfaceTypeDetailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(existing); // Add the MailSender field final FieldMetadataBuilder mailSenderFieldBuilder = new FieldMetadataBuilder( declaredByMetadataId, PRIVATE_TRANSIENT, annotations, fieldName, MAIL_SENDER); classOrInterfaceTypeDetailsBuilder.addField(mailSenderFieldBuilder.build()); // Add the "sendMessage" method classOrInterfaceTypeDetailsBuilder.addMethod( getSendMethod(fieldName, async, declaredByMetadataId, classOrInterfaceTypeDetailsBuilder)); typeManagementService.createOrUpdateTypeOnDisk(classOrInterfaceTypeDetailsBuilder.build()); }
public static String getProxyRendererType( final JavaPackage topLevelPackage, final JavaType javaType) { return GwtType.EDIT_RENDERER.getPath().packageName(topLevelPackage) + "." + javaType.getSimpleTypeName() + "Renderer"; }
private void createIdentifierClass(final JavaType identifierType) { final List<AnnotationMetadataBuilder> identifierAnnotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder identifierBuilder = new AnnotationMetadataBuilder(ROO_IDENTIFIER); identifierBuilder.addBooleanAttribute(DB_MANAGED.getSymbolName(), true); identifierAnnotations.add(identifierBuilder); // Produce identifier itself final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier( identifierType, projectOperations.getPathResolver().getFocusedPath(Path.SRC_MAIN_JAVA)); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder( declaredByMetadataId, Modifier.PUBLIC | Modifier.FINAL, identifierType, PhysicalTypeCategory.CLASS); cidBuilder.setAnnotations(identifierAnnotations); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build()); shell.flash( Level.FINE, "Created " + identifierType.getFullyQualifiedTypeName(), DbreDatabaseListenerImpl.class.getName()); shell.flash(Level.FINE, "", DbreDatabaseListenerImpl.class.getName()); }
/** * Returns the {@link #WEB_RECEIVER} Java type, generically typed to the given type. * * @param genericType (required) * @return a non-<code>null</code> type */ public static JavaType getReceiverType(final JavaType genericType) { return new JavaType( RECEIVER.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Collections.singletonList(genericType)); }
public boolean isPrimitive() { return type.isPrimitive() || isDate() || isString() || isBoolean() || type.equals(JavaType.DOUBLE_OBJECT) || type.equals(LONG_OBJECT) || type.equals(JavaType.INT_OBJECT) || type.equals(JavaType.FLOAT_OBJECT) || type.equals(JavaType.BYTE_OBJECT) || type.equals(JavaType.SHORT_OBJECT) || type.equals(JavaType.CHAR_OBJECT) || type.equals(BIG_DECIMAL); }
/** {@inheritDoc} */ public void annotateType(final JavaType type, final JavaPackage javaPackage) { // TODO check for existing controller // Use Roo's Assert type for null checks Validate.notNull(type, "Java type required"); Validate.notNull(javaPackage, "Java package required, web mvc all command package required"); // Obtain ClassOrInterfaceTypeDetails for this java type ClassOrInterfaceTypeDetails entityDetails = typeLocationService.getTypeDetails(type); // Test if the annotation already exists on the target type if (entityDetails != null && MemberFindingUtils.getAnnotationOfType( entityDetails.getAnnotations(), new JavaType(RooEnvers.class.getName())) == null) { ClassOrInterfaceTypeDetailsBuilder classOrInterfaceTypeDetailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(entityDetails); // Create JavaType instance for the add-ons trigger annotation JavaType rooEnvers = new JavaType(RooEnvers.class.getName()); // Create Annotation metadata AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(rooEnvers); // Add annotation to target type classOrInterfaceTypeDetailsBuilder.addAnnotation(annotationBuilder.build()); // Save changes to disk typeManagementService.createOrUpdateTypeOnDisk(classOrInterfaceTypeDetailsBuilder.build()); } // Get details for existing controller JavaType typeController = new JavaType( javaPackage.getFullyQualifiedPackageName() + "." + type.getSimpleTypeName() + "Controller"); ClassOrInterfaceTypeDetails typeControllerDetails = typeLocationService.getTypeDetails(typeController); // Add annotation @RooEnversController to existing controller ClassOrInterfaceTypeDetailsBuilder classOrInterfaceTypeDetailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(typeControllerDetails); JavaType rooEnversController = new JavaType("de.eightbitboy.roo.envers.controller.RooEnversController"); final List<AnnotationAttributeValue<?>> rooEnversControllerAttributes = new ArrayList<AnnotationAttributeValue<?>>(); rooEnversControllerAttributes.add(new ClassAttributeValue(new JavaSymbolName("type"), type)); AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(rooEnversController, rooEnversControllerAttributes); classOrInterfaceTypeDetailsBuilder.addAnnotation(annotationBuilder.build()); typeManagementService.createOrUpdateTypeOnDisk(classOrInterfaceTypeDetailsBuilder.build()); }
/** * 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); }
private JavaType getCollectionImplementation(final JavaType javaType) { if (javaType.equals(SET)) { return new JavaType( HASH_SET.getFullyQualifiedTypeName(), javaType.getArray(), javaType.getDataType(), javaType.getArgName(), javaType.getParameters()); } if (javaType.equals(LIST)) { return new JavaType( ARRAY_LIST.getFullyQualifiedTypeName(), javaType.getArray(), javaType.getDataType(), javaType.getArgName(), javaType.getParameters()); } return javaType; }
public boolean isProxy() { return ptmd != null && !isDate() && !isString() && !isPrimitive() && !isEnum() && !isCollection() && !isEmbeddable() && !type.equals(OBJECT); }
/** * Creates a new DBRE-managed entity from the given table * * @param javaType the name of the entity to be created (required) * @param table the table from which to create the entity (required) * @param activeRecord whether to create "active record" CRUD methods in the new entity * @return the newly created entity */ private ClassOrInterfaceTypeDetails createNewManagedEntityFromTable( final JavaType javaType, final Table table, final boolean activeRecord) { // Create type annotations for new entity final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(ROO_JAVA_BEAN)); annotations.add(new AnnotationMetadataBuilder(ROO_TO_STRING)); // Find primary key from db metadata and add identifier attributes to // @RooJpaEntity final AnnotationMetadataBuilder jpaAnnotationBuilder = new AnnotationMetadataBuilder(activeRecord ? ROO_JPA_ACTIVE_RECORD : ROO_JPA_ENTITY); manageIdentifier(javaType, jpaAnnotationBuilder, new HashSet<JavaSymbolName>(), table); if (!hasVersionField(table)) { jpaAnnotationBuilder.addStringAttribute(VERSION_FIELD, ""); } if (table.isDisableGeneratedIdentifiers()) { jpaAnnotationBuilder.addStringAttribute(SEQUENCE_NAME_FIELD, ""); } jpaAnnotationBuilder.addStringAttribute("table", table.getName()); if (!DbreModelService.NO_SCHEMA_REQUIRED.equals(table.getSchema().getName())) { jpaAnnotationBuilder.addStringAttribute("schema", table.getSchema().getName()); } annotations.add(jpaAnnotationBuilder); // Add @RooDbManaged annotations.add(getRooDbManagedAnnotation()); final JavaType superclass = OBJECT; final List<JavaType> extendsTypes = new ArrayList<JavaType>(); extendsTypes.add(superclass); // Create entity class final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier( javaType, projectOperations.getPathResolver().getFocusedPath(Path.SRC_MAIN_JAVA)); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder( declaredByMetadataId, Modifier.PUBLIC, javaType, PhysicalTypeCategory.CLASS); cidBuilder.setExtendsTypes(extendsTypes); cidBuilder.setAnnotations(annotations); final ClassOrInterfaceTypeDetails entity = cidBuilder.build(); typeManagementService.createOrUpdateTypeOnDisk(entity); shell.flash( Level.FINE, "Created " + javaType.getFullyQualifiedTypeName(), DbreDatabaseListenerImpl.class.getName()); shell.flash(Level.FINE, "", DbreDatabaseListenerImpl.class.getName()); return entity; }
private MethodMetadataBuilder getIdMethod( String declaredById, JavaType targetType, MethodMetadata idAccessor) { InvocableMemberBodyBuilder invocableMemberBodyBuilder = InvocableMemberBodyBuilder.getInstance(); invocableMemberBodyBuilder.append( "return " + StringUtils.uncapitalize(targetType.getSimpleTypeName()) + "." + idAccessor.getMethodName() + "();"); MethodMetadataBuilder getIdMethod = new MethodMetadataBuilder( declaredById, Modifier.PUBLIC, new JavaSymbolName("getId"), GwtUtils.convertPrimitiveType(idAccessor.getReturnType(), true), invocableMemberBodyBuilder); getIdMethod.addParameter(StringUtils.uncapitalize(targetType.getSimpleTypeName()), targetType); return getIdMethod; }
@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 TemplateDataDictionary buildStandardDataDictionary( final GwtType type, final String moduleName) { final JavaType javaType = new JavaType(getFullyQualifiedTypeName(type, moduleName)); final TemplateDataDictionary dataDictionary = TemplateDictionary.create(); for (final GwtType reference : type.getReferences()) { addReference(dataDictionary, reference, moduleName); } dataDictionary.setVariable("className", javaType.getSimpleTypeName()); dataDictionary.setVariable("packageName", javaType.getPackage().getFullyQualifiedPackageName()); dataDictionary.setVariable( "placePackage", GwtPath.SCAFFOLD_PLACE.packageName(projectOperations.getTopLevelPackage(moduleName))); dataDictionary.setVariable( "sharedScaffoldPackage", GwtPath.SHARED_SCAFFOLD.packageName(projectOperations.getTopLevelPackage(moduleName))); dataDictionary.setVariable( "sharedGaePackage", GwtPath.SHARED_GAE.packageName(projectOperations.getTopLevelPackage(moduleName))); return dataDictionary; }
private MethodMetadataBuilder getVersionMethod( String declaredById, JavaType targetType, MethodMetadata versionAccessor) { InvocableMemberBodyBuilder invocableMemberBodyBuilder = InvocableMemberBodyBuilder.getInstance(); invocableMemberBodyBuilder.append( "return " + StringUtils.uncapitalize(targetType.getSimpleTypeName()) + "." + versionAccessor.getMethodName() + "();"); MethodMetadataBuilder getIdMethodBuilder = new MethodMetadataBuilder( declaredById, Modifier.PUBLIC, new JavaSymbolName("getVersion"), JavaType.OBJECT, invocableMemberBodyBuilder); getIdMethodBuilder.addParameter( StringUtils.uncapitalize(targetType.getSimpleTypeName()), targetType); return getIdMethodBuilder; }
public static JavaType convertGovernorTypeNameIntoKeyTypeName( final JavaType governorType, final GwtType type, final ProjectMetadata projectMetadata) { String destinationPackage = type.getPath().packageName(projectMetadata); String typeName; if (type.isMirrorType()) { String simple = governorType.getSimpleTypeName(); typeName = destinationPackage + "." + simple + type.getSuffix(); } else { typeName = destinationPackage + "." + type.getTemplate(); } return new JavaType(typeName); }
public String getFormatter() { if (isCollectionOfProxy()) { return getCollectionRenderer() + ".render"; } else if (isDate()) { return getDateTimeFormat() + ".format"; } else if (type.equals(JavaType.INT_OBJECT) || type.equals(JavaType.FLOAT_OBJECT) || type.equals(JavaType.DOUBLE_OBJECT) || type.equals(BIG_INTEGER) || type.equals(BIG_DECIMAL)) { String formatter = "String.valueOf"; if (annotations == null || annotations.isEmpty()) { return formatter; } AnnotationMetadata annotation = MemberFindingUtils.getAnnotationOfType(annotations, NUMBER_FORMAT); if (annotation != null) { AnnotationAttributeValue<?> attr = annotation.getAttribute(new JavaSymbolName("style")); if (attr != null) { String style = attr.getValue().toString(); if ("org.springframework.format.annotation.NumberFormat.Style.CURRENCY".equals(style)) { formatter = "NumberFormat.getCurrencyFormat().format"; } else if ("org.springframework.format.annotation.NumberFormat.Style.PERCENT" .equals(style)) { formatter = "NumberFormat.getPercentFormat().format"; } else { formatter = "NumberFormat.getDecimalFormat().format"; } } else { formatter = "NumberFormat.getDecimalFormat().format"; } } return formatter; } else if (isProxy()) { return getProxyRendererType() + ".instance().render"; } else { return "String.valueOf"; } }
public String getRenderer() { return isCollection() ? getCollectionRenderer() : isDate() ? "new DateTimeFormatRenderer(" + getDateTimeFormat() + ")" : isPrimitive() || isEnum() || isEmbeddable() || type.equals(OBJECT) ? "new AbstractRenderer<" + getType() + ">() {\n public String render(" + getType() + " obj) {\n return obj == null ? \"\" : String.valueOf(obj);\n }\n }" : getProxyRendererType() + ".instance()"; }
public String forEditView() { String initializer = ""; if (isBoolean()) { initializer = " = " + getCheckboxSubtype(); } if (isEnum() && !isCollection()) { initializer = String.format( " = new ValueListBox<%s>(%s)", type.getFullyQualifiedTypeName(), getRenderer()); } if (isProxy()) { initializer = String.format( " = new ValueListBox<%1$s>(%2$s.instance(), new com.google.web.bindery.requestfactory.gwt.ui.client.EntityProxyKeyProvider<%1$s>())", type.getFullyQualifiedTypeName(), getProxyRendererType()); } return String.format("@UiField %s %s %s", getEditor(), getName(), initializer); }
private boolean isNumberOrDate(JavaType fieldType) { return fieldType.equals(JavaType.DOUBLE_OBJECT) || fieldType.equals(JavaType.FLOAT_OBJECT) || fieldType.equals(JavaType.INT_OBJECT) || fieldType.equals(LONG_OBJECT) || fieldType.equals(JavaType.SHORT_OBJECT) || fieldType.getFullyQualifiedTypeName().equals(Date.class.getName()) || fieldType.getFullyQualifiedTypeName().equals(Calendar.class.getName()); }