@Override public void visitObject(ObjectType objectType) { if (!isCustomStaticType(objectType)) { objectType.getOpenRestriction().ifPresent(t -> checkValidType(component, extensionModel, t, problemsReporter)); checkValidType(component, extensionModel, objectType, problemsReporter); } }
@Override public void visitObject(ObjectType objectType) { if (objectType.isOpen()) { objectType.getOpenRestriction().get().accept(this); } else { declarer.withType(objectType); } }
@Override public void visitObject(ObjectType objectType) { if (objectType.getMetadataFormat() != JAVA) { return; } final Class<Object> clazz = getType(objectType).orElse(null); if (clazz == null || relativeClasses.contains(clazz)) { return; } Optional<ClassInformationAnnotation> classInformation = objectType.getAnnotation(ClassInformationAnnotation.class); if (classInformation.isPresent()) { classInformation.get().getGenericTypes() .forEach(generic -> relativeClasses.add(loadClass(generic, extensionClassLoader))); } relativeClasses.add(clazz); objectType.getFields().stream().forEach(objectFieldType -> objectFieldType.accept(this)); objectType.getOpenRestriction().ifPresent(t -> t.accept(this)); }
@Override public void visitObject(ObjectType objectType) { if (objectType.getMetadataFormat() != JAVA) { return; } final String clazz = getId(objectType).orElse(null); if (clazz == null || relativeClasses.contains(clazz)) { return; } Optional<ClassInformationAnnotation> classInformation = objectType.getAnnotation(ClassInformationAnnotation.class); classInformation .ifPresent(classInformationAnnotation -> relativeClasses .addAll(classInformationAnnotation.getGenericTypes())); relativeClasses.add(clazz); objectType.getFields().forEach(objectFieldType -> objectFieldType.accept(this)); objectType.getOpenRestriction().ifPresent(t -> t.accept(this)); }
@Override public void visitObject(ObjectType objectType) { type = new DefaultObjectType(objectType.getFields(), objectType.isOrdered(), objectType.getOpenRestriction().orElse(null), objectType.getMetadataFormat(), getAllTypeAnnotationsMap()); }
private void assertDictionary(MetadataType metadataType, Class<?> valueType) { assertThat(metadataType, is(instanceOf(ObjectType.class))); ObjectType dictionaryType = (ObjectType) metadataType; assertType(dictionaryType, Map.class); assertThat(dictionaryType.getOpenRestriction().isPresent(), is(true)); assertType(dictionaryType.getOpenRestriction().get(), valueType); }
@Override public void visitObject(ObjectType objectType) { if (config.getConfigAttributes().isEmpty() && config.getChildren().isEmpty()) { defaultVisit(objectType); return; } ParameterObjectValue.Builder objectValue = ElementDeclarer.newObjectValue(); if (isMap(objectType)) { createMapValue(objectValue, config, objectType.getOpenRestriction().orElse(null)); } else { if (paramDsl.isWrapped()) { if (config.getChildren().size() == 1) { createWrappedObject(objectType, objectValue, config); } } else { createObjectValueFromType(objectType, objectValue, config, paramDsl); } } valueConsumer.accept(objectValue.build()); } };
@Override public void visitObject(ObjectType objectType) { if (Map.class.isAssignableFrom(type)) { dataType.set(DataType.builder().mapType((Class<? extends Map>) type) .keyType(String.class) .valueType(objectType.getOpenRestriction() .map(restriction -> { if (restriction.getAnnotation(TypedValueTypeAnnotation.class).isPresent()) { return TypedValue.class; } return getType(restriction).get(); }) .orElse(Object.class)) .build()); } else { defaultVisit(objectType); } } });
@Override public void visitObject(ObjectType objectType) { if (!visitedTypes.add(objectType)) { return; } if (isMap(objectType)) { objectType.getAnnotation(ClassInformationAnnotation.class) .filter(classInformation -> !classInformation.getGenericTypes().isEmpty()) .filter(classInformation -> !Objects.equals(classInformation.getGenericTypes().get(0), String.class.getName())) .ifPresent(classInformation -> problemsReporter.addError(new Problem(parameter, format( "Parameter '%s' is of type '%s' and its key type is not %s ", parameter.getName(), getType(objectType).getName(), String.class.getName())))); objectType.getOpenRestriction().get().accept(this); } else { parameter.getModelProperty(ExtensionParameterDescriptorModelProperty.class) .map(descriptor -> descriptor.getExtensionParameter().getType()) .ifPresent(type -> { final String typeName = type.getName(); type.getFields() .forEach(field -> checkInvalidFieldAnnotations(parameter, typeName, field, ConfigOverride.class, ComponentId.class, MetadataKeyId.class, MetadataKeyPart.class)); }); } objectType.getFields().forEach(f -> f.getValue().accept(this)); }
@Test public void mapWithNoGenerics() throws Exception { MetadataType returnType = IntrospectionUtils.getMethodReturnType(getMethod("mapNoGenerics")); assertThat(returnType, instanceOf(ObjectType.class)); assertThat(((ObjectType) returnType).getOpenRestriction().get(), instanceOf(AnyType.class)); }
@Test public void attributesDynamicPersonTypeMetadata() throws Exception { location = Location.builder().globalName(OUTPUT_ATTRIBUTES_WITH_DYNAMIC_METADATA).addProcessorsPart().addIndexPart(0).build(); final ComponentMetadataDescriptor<OperationModel> metadataDescriptor = getSuccessComponentDynamicMetadataWithKey(PERSON_METADATA_KEY); final OperationModel typedModel = metadataDescriptor.getModel(); MetadataType type = typedModel.getOutputAttributes().getType(); assertThat(type, is(instanceOf(ObjectType.class))); ObjectType dictionary = (ObjectType) type; assertThat(dictionary.getOpenRestriction().get(), is(instanceOf(StringType.class))); }
private void populateMapEntries(ObjectType objectType, DslElementSyntax modelDsl, DslElementModel.Builder mapBuilder, ComponentConfiguration mapConfig) { mapConfig.getNestedComponents().forEach(entryConfig -> { MetadataType entryType = objectType.getOpenRestriction().get(); modelDsl.getGeneric(entryType).ifPresent(entryDsl -> { DslElementModel.Builder<Object> entry = DslElementModel.builder() .withModel(entryType) .withConfig(entryConfig) .withDsl(entryDsl); entry.containing(DslElementModel.builder() .withModel(typeLoader.load(String.class)) .withValue(entryConfig.getParameters().get(KEY_ATTRIBUTE_NAME)) .withDsl(entryDsl.getAttribute(KEY_ATTRIBUTE_NAME).get()) .build()); String value = entryConfig.getParameters().get(VALUE_ATTRIBUTE_NAME); if (isBlank(value)) { getComponentChildVisitor(entry, entryConfig, entryType, VALUE_ATTRIBUTE_NAME, entryDsl.getAttribute(VALUE_ATTRIBUTE_NAME).get(), empty(), new ArrayDeque<>()); } else { entry.containing(DslElementModel.builder() .withModel(typeLoader.load(String.class)) .withValue(value) .withDsl(entryDsl.getAttribute(VALUE_ATTRIBUTE_NAME).get()) .build()); } mapBuilder.containing(entry.build()); }); }); }
private LocalComplexType generateMapComplexType(DslElementSyntax mapDsl, final ObjectType metadataType) { final MetadataType valueType = metadataType.getOpenRestriction().get(); final LocalComplexType entryComplexType = new LocalComplexType(); final Attribute keyAttribute = builder.createAttribute(KEY_ATTRIBUTE_NAME, keyType, true, REQUIRED);
final MetadataType valueType = dictionaryType.getOpenRestriction().orElse(typeLoader.load(Object.class)); final Class<?> valueClass = getType(valueType); final MetadataType keyType = typeLoader.load(String.class);
@Override public void visitObject(ObjectType objectType) { if (!isCustomStaticType(objectType)) { objectType.getOpenRestriction().ifPresent(t -> checkValidType(component, extensionModel, t, problemsReporter)); checkValidType(component, extensionModel, objectType, problemsReporter); } }
.withDsl(paramDsl); MetadataType valueType = mapType.getOpenRestriction().get();
@Override public void visitObject(ObjectType objectType) { if (objectType.isOpen()) { objectType.getOpenRestriction().get().accept(this); } else { declarer.withType(objectType); } }
@Override public void visitObject(ObjectType objectType) { type = new DefaultObjectType(objectType.getFields(), objectType.isOrdered(), objectType.getOpenRestriction().orElse(null), objectType.getMetadataFormat(), getAllTypeAnnotationsMap()); }
private void assertMapTypes(Class<? extends Map> mapType, Class containerType, Class valueType) { assertThat(handler.handles(mapType), is(true)); objectFieldHandler.handleFields(containerType, createDefault(), new ParsingContext(), typeBuilder); List<ObjectFieldType> fields = getFields(typeBuilder); assertThat(fields.isEmpty(), is(false)); ObjectType field = (ObjectType) fields.get(0).getValue(); assertThat(field.isOpen(), is(true)); assertThat(field.getOpenRestriction().get(), instanceOf(valueType)); }
@Test public void attributesDynamicPersonTypeMetadata() throws Exception { location = Location.builder().globalName(OUTPUT_ATTRIBUTES_WITH_DYNAMIC_METADATA).addProcessorsPart().addIndexPart(0).build(); final ComponentMetadataDescriptor<OperationModel> metadataDescriptor = getSuccessComponentDynamicMetadataWithKey(PERSON_METADATA_KEY); final OperationModel typedModel = metadataDescriptor.getModel(); MetadataType type = typedModel.getOutputAttributes().getType(); assertThat(type, is(instanceOf(ObjectType.class))); ObjectType dictionary = (ObjectType) type; assertThat(dictionary.getOpenRestriction().get(), is(instanceOf(StringType.class))); }