@Test public void reactivexTypes() { Contract contract = new ReactiveDelegatingContract(new Contract.Default()); contract.parseAndValidateMetadata(TestReactiveXService.class); }
@Override public List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType) { List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactive(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns a org.reactivestreams.Publisher", metadata.configKey(), targetType.getSimpleName())); } Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments(); if (actualTypes.length > 1) { throw new IllegalStateException("Expected only one contained type."); } else { Class<?> actual = Types.getRawType(actualTypes[0]); if (Stream.class.isAssignableFrom(actual)) { throw new IllegalArgumentException( "Streams are not supported when using Reactive Wrappers"); } metadata.returnType(actualTypes[0]); } } return methodsMetadata; }
ReactiveDelegatingContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType) { List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactive(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns a org.reactivestreams.Publisher", metadata.configKey(), targetType.getSimpleName())); } Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments(); if (actualTypes.length > 1) { throw new IllegalStateException("Expected only one contained type."); } else { Class<?> actual = Types.getRawType(actualTypes[0]); if (Stream.class.isAssignableFrom(actual)) { throw new IllegalArgumentException( "Streams are not supported when using Reactive Wrappers"); } metadata.returnType(actualTypes[0]); } } return methodsMetadata; } }
ReactiveDelegatingContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType) { List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactive(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns a org.reactivestreams.Publisher", metadata.configKey(), targetType.getSimpleName())); } Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments(); if (actualTypes.length > 1) { throw new IllegalStateException("Expected only one contained type."); } else { Class<?> actual = Types.getRawType(actualTypes[0]); if (Stream.class.isAssignableFrom(actual)) { throw new IllegalArgumentException( "Streams are not supported when using Reactive Wrappers"); } metadata.returnType(actualTypes[0]); } } return methodsMetadata; } ReactiveDelegatingContract(Contract delegate); }
ReactiveDelegatingContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType) { List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactive(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns a org.reactivestreams.Publisher", metadata.configKey(), targetType.getSimpleName())); } Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments(); if (actualTypes.length > 1) { throw new IllegalStateException("Expected only one contained type."); } else { Class<?> actual = Types.getRawType(actualTypes[0]); if (Stream.class.isAssignableFrom(actual)) { throw new IllegalArgumentException( "Streams are not supported when using Reactive Wrappers"); } metadata.returnType(actualTypes[0]); } } return methodsMetadata; } ReactiveDelegatingContract(Contract delegate); @Override List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType); }
ReactiveDelegatingContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType) { List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactive(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns a org.reactivestreams.Publisher", metadata.configKey(), targetType.getSimpleName())); } Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments(); if (actualTypes.length > 1) { throw new IllegalStateException("Expected only one contained type."); } else { Class<?> actual = Types.getRawType(actualTypes[0]); if (Stream.class.isAssignableFrom(actual)) { throw new IllegalArgumentException( "Streams are not supported when using Reactive Wrappers"); } metadata.returnType(actualTypes[0]); } } return methodsMetadata; } ReactiveDelegatingContract(Contract delegate); @Override List<MethodMetadata> parseAndValidateMetadata(Class<?> targetType);  }