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(); }
public ArrayTypeBuilder with(TypeAnnotation extension) { this.addExtension(extension); return this; }
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; }
@Override public void visitArrayType(ArrayType arrayType) { type = withNewAnnotations(typeBuilder.arrayType().of(arrayType.getType())); }
@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; } }
final String description = arraySchema.getDescription(); if (isNotEmpty(description)) { arrayMetadataBuilder.description(description); arrayMetadataBuilder.label(title); arrayMetadataBuilder.uniques(); arrayMetadataBuilder.boundary(min, max); arrayMetadataBuilder.of(handlerManager.handle(arrayType, parsingContext)); } else { arrayMetadataBuilder.of().anyType();
@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; } }
public ArrayTypeBuilder label(String label) { return with(new LabelAnnotation(label)); }
public ArrayTypeBuilder arrayType() { final ArrayTypeBuilder metadataBuilder = new ArrayTypeBuilder(format); builder = Optional.of(metadataBuilder); return metadataBuilder; }
@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); }
@Override public void visitArrayType(ArrayType arrayType) { type = withNewAnnotations(typeBuilder.arrayType().of(arrayType.getType())); }
@Override public TypeBuilder<?> handleClass(Class<?> clazz, List<Type> genericTypes, TypeHandlerManager typeHandlerManager, ParsingContext context, BaseTypeBuilder typeBuilder) { final Optional<Type> type = getGenericType(clazz, genericTypes); final ArrayTypeBuilder arrayType = typeBuilder.arrayType().with(new ClassInformationAnnotation(clazz, genericTypes)); context.addTypeBuilder(clazz, arrayType); if (type.isPresent()) { final Type arrayGenericType = type.get(); final Optional<TypeBuilder<?>> mayBeBuilder = context.getTypeBuilder(arrayGenericType); if (mayBeBuilder.isPresent()) { arrayType.of(mayBeBuilder.get()); } else { typeHandlerManager.handle(arrayGenericType, context, arrayType.of()); } } else { arrayType.of().anyType(); } return arrayType; }
@Override public TypeBuilder<?> handleClass(Class<?> clazz, List<Type> genericTypes, TypeHandlerManager typeHandlerManager, ParsingContext context, BaseTypeBuilder<?> typeBuilder) { final Optional<Type> type = getGenericType(clazz, genericTypes); final ArrayTypeBuilder<?> arrayType = typeBuilder.arrayType(); context.addTypeBuilder(clazz, arrayType); if (clazz.getCanonicalName() != null) { arrayType.id(clazz.getCanonicalName()); } if (type.isPresent()) { final Type arrayGenericType = type.get(); final Optional<TypeBuilder<?>> mayBeBuilder = context.getTypeBuilder(arrayGenericType); if (mayBeBuilder.isPresent()) { arrayType.of(mayBeBuilder.get()); } else { typeHandlerManager.handle(arrayGenericType, context, arrayType.of()); } } else { arrayType.of().anyType(); } return arrayType; }
public ArrayTypeBuilder description(String content) { return with(new DescriptionAnnotation(content)); }
@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); }
@Override public TypeBuilder<?> handle(JsonElement jsonElement, BaseTypeBuilder root, HandlerManager handlerManager, ParsingContext parsingContext) { JsonArray array = (JsonArray) jsonElement; final ArrayTypeBuilder arrayMetadataBuilder = root.arrayType(); parsingContext.getAnnotations().forEach(arrayMetadataBuilder::with); final JsonElement arraySample = getFirstChild(array); if (arraySample != null) { List<MetadataType> uniqueTypes = new ArrayList<>(); Map<MetadataType, TypeBuilder<?>> builders = new LinkedHashMap<>(); for (Iterator<JsonElement> it = array.iterator(); it.hasNext();) { JsonElement item = it.next(); TypeBuilder<?> itemBuilder = handlerManager.handle(item, new ParsingContext()); MetadataType type = itemBuilder.build(); if (!builders.containsKey(type)) { builders.put(type, itemBuilder); } } // Create union or simple type if (builders.size() > 1) { UnionTypeBuilder unionTypeBuilder = arrayMetadataBuilder.of().unionType(); builders.values().forEach(unionTypeBuilder::of); } else { arrayMetadataBuilder.of(handlerManager.handle(arraySample, new ParsingContext())); } } else { arrayMetadataBuilder.of().anyType(); } return arrayMetadataBuilder; }
public ArrayTypeBuilder id(String typeIdentifier) { return with(new TypeIdAnnotation(typeIdentifier)); }
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 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)); }