Java Code Examples for org.springframework.core.ResolvableType#forClassWithGenerics()

@Test
public void writeServerSentEventsWithBuilder() throws Exception {

	ResolvableType type = ResolvableType.forClassWithGenerics(ServerSentEvent.class, String.class);

	EmitterProcessor<ServerSentEvent<?>> processor = EmitterProcessor.create();
	SseEmitter sseEmitter = (SseEmitter) handleValue(processor, Flux.class, type);

	EmitterHandler emitterHandler = new EmitterHandler();
	sseEmitter.initialize(emitterHandler);

	processor.onNext(ServerSentEvent.builder("foo").id("1").build());
	processor.onNext(ServerSentEvent.builder("bar").id("2").build());
	processor.onNext(ServerSentEvent.builder("baz").id("3").build());
	processor.onComplete();

	assertEquals("id:1\ndata:foo\n\nid:2\ndata:bar\n\nid:3\ndata:baz\n\n",
			emitterHandler.getValuesAsText());
}
 

private void bindValue(Bindable<?> target, Collection<Object> collection,
                       ResolvableType aggregateType, ResolvableType elementType, Object value) {
    if (value instanceof String && !StringUtils.hasText((String) value)) {
        return;
    }
    Object aggregate = convert(value, aggregateType, target.getAnnotations());
    ResolvableType collectionType = ResolvableType
            .forClassWithGenerics(collection.getClass(), elementType);
    Collection<Object> elements = convert(aggregate, collectionType);
    collection.addAll(elements);
}
 

@Override
public void decodeToMono() {
	List<Pojo> expected = Arrays.asList(pojo1, pojo2);

	Flux<DataBuffer> input = Flux.just(expected)
			.map(this::writeObject)
			.flatMap(this::dataBuffer);

	ResolvableType elementType = ResolvableType.forClassWithGenerics(List.class, Pojo.class);
	testDecodeToMono(input, elementType, step -> step
			.expectNext(expected)
			.expectComplete()
			.verify(), null, null);
}
 

private ResolvableType output(Class<?> type) {
	ResolvableType generic;
	ResolvableType raw = ResolvableType.forClass(type);
	if (isMessage()) {
		raw = ResolvableType.forClassWithGenerics(Message.class, raw);
	}
	if (FunctionType.isWrapper(getOutputWrapper())) {
		generic = ResolvableType.forClassWithGenerics(getOutputWrapper(), raw);
	}
	else {
		generic = raw;
	}
	return generic;
}
 

@Override
public ResolvableType getResolvableType() {
	return ResolvableType.forClassWithGenerics(getClass(), this.entity.getClass());
}
 

@Override
public ResolvableType getResolvableType() {
	return ResolvableType.forClassWithGenerics(getClass(), ResolvableType.forInstance(getPayload()));
}
 

public SmartGenericTestEvent(Object source, T payload) {
	super(source, payload);
	this.resolvableType = ResolvableType.forClassWithGenerics(
			getClass(), payload.getClass());
}
 

@Override
public ResolvableType getResolvableType() {
    return ResolvableType.forClassWithGenerics(getClass(),
            ResolvableType.forInstance(getSource()));
}
 

@Override
public ResolvableType getResolvableType() {
	return ResolvableType.forClassWithGenerics(getClass(), this.entity.getClass());
}
 

@Override
public ResolvableType getResolvableType() {
	return ResolvableType.forClassWithGenerics(getClass(), ResolvableType.forInstance(getPayload()));
}
 

@Override
public ResolvableType getResolvableType() {
    return ResolvableType.forClassWithGenerics(getClass(),
            ResolvableType.forInstance(message));
}
 

@Override
public ResolvableType getResolvableType() {
    return ResolvableType.forClassWithGenerics(getClass(),
            ResolvableType.forInstance(packet));
}
 

private static ResolvableType toResolvableType(Class<?> type, Class<?>... generics) {
	return (ObjectUtils.isEmpty(generics) ? ResolvableType.forClass(type) :
			ResolvableType.forClassWithGenerics(type, generics));
}
 

private static ResolvableType toResolvableType(Class<?> type, Class<?>... generics) {
	return (ObjectUtils.isEmpty(generics) ? ResolvableType.forClass(type) :
			ResolvableType.forClassWithGenerics(type, generics));
}
 

@Override
public ResolvableType getResolvableType() {
	return ResolvableType.forClassWithGenerics(getClass(), ResolvableType.forInstance(getPayload()));
}
 

private static ResolvableType toResolvableType(Class<?> type, ResolvableType generic, ResolvableType... generics) {
	ResolvableType[] genericTypes = new ResolvableType[generics.length + 1];
	genericTypes[0] = generic;
	System.arraycopy(generics, 0, genericTypes, 1, generics.length);
	return ResolvableType.forClassWithGenerics(type, genericTypes);
}
 

private static ResolvableType fromTwoArityFunction(Method functionalMethod) {
	return  ResolvableType.forClassWithGenerics(Tuple2.class,
			ResolvableType.forMethodParameter(functionalMethod, 0),
			ResolvableType.forMethodParameter(functionalMethod, 1));
}
 

private static ResolvableType toResolvableType(Class<?> type, ResolvableType generic, ResolvableType... generics) {
	ResolvableType[] genericTypes = new ResolvableType[generics.length + 1];
	genericTypes[0] = generic;
	System.arraycopy(generics, 0, genericTypes, 1, generics.length);
	return ResolvableType.forClassWithGenerics(type, genericTypes);
}
 

private ResolvableType createGenericEventType(Class<?> payloadType) {
	return ResolvableType.forClassWithGenerics(PayloadApplicationEvent.class, payloadType);
}
 

/**
 * Create a new type descriptor from a {@link java.util.Collection} type.
 * <p>Useful for converting to typed Collections.
 * <p>For example, a {@code List<String>} could be converted to a
 * {@code List<EmailAddress>} by converting to a targetType built with this method.
 * The method call to construct such a {@code TypeDescriptor} would look something
 * like: {@code collection(List.class, TypeDescriptor.valueOf(EmailAddress.class));}
 * @param collectionType the collection type, which must implement {@link Collection}.
 * @param elementTypeDescriptor a descriptor for the collection's element type,
 * used to convert collection elements
 * @return the collection type descriptor
 */
public static TypeDescriptor collection(Class<?> collectionType, TypeDescriptor elementTypeDescriptor) {
	Assert.notNull(collectionType, "Collection type must not be null");
	if (!Collection.class.isAssignableFrom(collectionType)) {
		throw new IllegalArgumentException("Collection type must be a [java.util.Collection]");
	}
	ResolvableType element = (elementTypeDescriptor != null ? elementTypeDescriptor.resolvableType : null);
	return new TypeDescriptor(ResolvableType.forClassWithGenerics(collectionType, element), null, null);
}