@Override public void visitArrayType(ArrayType arrayType) { type = withNewAnnotations(typeBuilder.arrayType().of(arrayType.getType())); }
private static ArrayType getListOfMessageType(Type returnType, MetadataType outputType, MetadataType attributesOutputType) { return typeBuilder().arrayType() .of(new MessageMetadataTypeBuilder() .payload(outputType) .attributes(attributesOutputType) .build()) .with(returnType.getClassInformation()) .build(); }
@Test public void enumCollectionTransformer() throws Exception { DefaultExtensionManager extensionsManager = new DefaultExtensionManager(); extensionsManager.setMuleContext(muleContext); extensionsManager.initialise(); ParameterModel parameter = mock(ParameterModel.class); when(parameter.getType()) .thenReturn(create(JAVA).arrayType().of(toMetadataType(TimeUnit.class)).build()); mockParameters(extension1ConfigurationModel, parameter); extensionsManager.registerExtension(extensionModel1); verify(muleContext.getRegistry()).registerObject(anyString(), any(StringToEnum.class), eq(Transformer.class)); }
@Test public void sourceReturnsArrayTypeOfObjectWithoutDefinedOutputResolver() { exception.expect(IllegalModelDefinitionException.class); exception.expectMessage(""); arrayType = typeBuilder.arrayType().of(toMetadataType(Object.class)).build(); when(sourceModel.getOutput()).thenReturn(new ImmutableOutputModel("", arrayType, false, emptySet())); validate(extensionModel, validator); }
@Test public void sourceReturnsArrayTypeOfDictionaryWithObjectValue() { exception.expect(IllegalModelDefinitionException.class); exception.expectMessage("declares a collection of "); arrayType = typeBuilder.arrayType().of(dictionaryType).build(); when(sourceModel.getOutput()).thenReturn(new ImmutableOutputModel("", arrayType, false, emptySet())); validate(extensionModel, validator); }
public static ArrayType arrayOf(Class<? extends Collection> clazz, TypeBuilder itemType) { return TYPE_BUILDER.arrayType() .of(itemType) .with(new ClassInformationAnnotation(clazz)) .build(); }
private MetadataType adaptToListIfNecessary(MetadataType resolvedType, ParameterModel parameter, MetadataContext metadataContext) throws MetadataResolvingException { MetadataType inputType = parameter.getType(); if (!isCollection(inputType) || isNullType(resolvedType)) { return resolvedType; } return metadataContext.getTypeBuilder().arrayType() .with(new ClassInformationAnnotation(getType(inputType))) .of(resolvedType) .build(); } }
@Test public void getDataTypeFromList() { Class<List> listClass = List.class; Class<Integer> integerClass = Integer.class; ArrayTypeBuilder arrayTypeBuilder = BaseTypeBuilder.create(JAVA) .arrayType() .with(new ClassInformationAnnotation(listClass)); arrayTypeBuilder.of().numberType().integer(); CollectionDataType dataType = (CollectionDataType) toDataType(arrayTypeBuilder.build()); assertThat(dataType.getType(), is(equalTo(listClass))); assertThat(dataType.getItemDataType().getType(), is(equalTo(integerClass))); }
private MetadataType listOfString() { return TYPE_BUILDER.arrayType().of(TYPE_BUILDER.stringType()).with(new ClassInformationAnnotation(List.class)).build(); }
public static MetadataType getMetadataType(Type type) { MetadataType metadataType = type.asMetadataType(); if (isAnyType(type)) { return enricher.enrich(ANY_TYPE, metadataType.getAnnotations()); } if (isArrayOfAny(type)) { return enricher.enrich(typeBuilder().arrayType().of(typeBuilder().anyType()).build(), metadataType.getAnnotations()); } return metadataType; }
private MetadataType adaptToListIfNecessary(MetadataType resolvedType, Object key, MetadataContext metadataContext) throws MetadataResolvingException { MetadataType componentOutputType = ((HasOutputModel) component).getOutput().getType(); if (!isCollection(componentOutputType) || isVoid(resolvedType) || isNullType(resolvedType)) { return resolvedType; } MetadataType collectionValueType = ((ArrayType) componentOutputType).getType(); Class<?> collectionType = getCollectionType(collectionValueType); if (Message.class.equals(collectionType)) { MessageMetadataType message = (MessageMetadataType) collectionValueType; resolvedType = wrapInMessageType(resolvedType, key, metadataContext, message.getAttributesType()); } return metadataContext.getTypeBuilder().arrayType() .with(new ClassInformationAnnotation(getCollectionType(componentOutputType))) .of(resolvedType) .build(); }
@Test public void operationWithResultInputStreamCollectionOutput() throws Exception { MetadataType metadataType = BaseTypeBuilder.create(JAVA).arrayType().of(new MessageMetadataTypeBuilder().build()).build(); when(outputModel.getType()).thenReturn(metadataType); when(componentModel.supportsStreaming()).thenReturn(true); delegate = createReturnDelegate(); List<Result> resultList = new ArrayList<>(); resultList.add(Result.builder().output(new ByteArrayInputStream(HELLO_WORLD_MSG.getBytes(UTF_8))).build()); CoreEvent result = delegate.asReturnValue(resultList, operationContext); Message message = getOutputMessage(result); Message message1 = ((ResultsToMessageList) message.getPayload().getValue()).get(0); ManagedCursorStreamProvider actual = (ManagedCursorStreamProvider) message1.getPayload().getValue(); InputStream resultingStream = actual.openCursor(); assertThat(IOUtils.toString(resultingStream), is(HELLO_WORLD_MSG)); resultingStream.close(); actual.releaseResources(); disposeStreamingManager(); probe(5000, 500, () -> { verify(connectionHandler, atLeastOnce()).release(); return true; }); }
} else { return typeBuilder().arrayType() .of(itemType.asMetadataType()) .with(returnType.getClassInformation()) .build();
@Parameters(name = "isSimpleType({0})") public static Collection<Object[]> data() { return Arrays.asList(new Object[][] {{BUILDER.stringType().build(), true}, {BUILDER.numberType().build(), true}, {BUILDER.booleanType().build(), true}, {BUILDER.objectType().build(), false}, {BUILDER.arrayType().of(BUILDER.stringType()).build(), false}, {BUILDER.dateTimeType().build(), false}}); }
@Override public TypeBuilder<?> handleClass(Class<?> clazz, List<Type> genericTypes, TypeHandlerManager typeHandlerManager, ParsingContext context, BaseTypeBuilder<?> typeBuilder) { final ArrayTypeBuilder<?> arrayType = typeBuilder.arrayType().id(clazz.getCanonicalName()); final Class<?> componentType = clazz.getComponentType(); final Optional<TypeBuilder<?>> mayBeType = context.getTypeBuilder(componentType); if (mayBeType.isPresent()) { arrayType.of(mayBeType.get()); } else { typeHandlerManager.handle(componentType, context, arrayType.of()); } return arrayType; } }
@Override public TypeBuilder<?> handleClass(Class<?> clazz, List<Type> genericTypes, TypeHandlerManager typeHandlerManager, ParsingContext context, BaseTypeBuilder typeBuilder) { final Class<?> componentType = clazz.getComponentType(); final ArrayTypeBuilder arrayType = typeBuilder.arrayType().with(new ClassInformationAnnotation(clazz)); final Optional<TypeBuilder<?>> mayBeType = context.getTypeBuilder(componentType); if (mayBeType.isPresent()) { arrayType.of(mayBeType.get()); } else { typeHandlerManager.handle(componentType, context, arrayType.of()); } return arrayType; } }
@Override public void visitArrayType(ArrayType arrayType) { type = withNewAnnotations(typeBuilder.arrayType().of(arrayType.getType())); }
.with(new ClassInformationAnnotation(Map.class, asList(String.class, List.class))) .openWith(TYPE_BUILDER.arrayType() .of(TYPE_BUILDER.stringType())) .build(), false, SUPPORTED, null); false, SUPPORTED, null); assertParameter(parameters, "healthProgressions", "", TYPE_BUILDER.arrayType().of(TYPE_LOADER.load(HealthStatus.class)).build(), false, SUPPORTED, null);
private static ArrayType getListOfMessageType(Type returnType, MetadataType outputType, MetadataType attributesOutputType) { return typeBuilder().arrayType() .of(new MessageMetadataTypeBuilder() .payload(outputType) .attributes(attributesOutputType) .build()) .with(returnType.getClassInformation()) .build(); }
private MetadataType adaptToListIfNecessary(MetadataType resolvedType, ParameterModel parameter, MetadataContext metadataContext) throws MetadataResolvingException { MetadataType inputType = parameter.getType(); if (!isCollection(inputType) || isNullType(resolvedType)) { return resolvedType; } return metadataContext.getTypeBuilder().arrayType() .with(new ClassInformationAnnotation(getType(inputType))) .of(resolvedType) .build(); } }