org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine Java Examples

private static ReactiveStreamsEngine loadFromSpi(ClassLoader cl) {
    if (cl == null) {
        return null;
    }
    if (instance == null) {
        ServiceLoader<ReactiveStreamsEngine> sl = ServiceLoader.load(
            ReactiveStreamsEngine.class, cl);
        for (ReactiveStreamsEngine spi : sl) {
            if (instance != null) {
                throw new IllegalStateException(
                    "Multiple ReactiveStreamsEngine implementations found: "
                        + spi.getClass().getName() + " and "
                        + instance.getClass().getName());
            }
            else {
                instance = spi;
            }
        }
    }
    return instance;
}
 

/**
 * Creates a ReactiveStreamsFactory object
 * Only used internally from within {@link ReactiveStreams}
 *
 * @return ReactiveStreamsFactory an instance of ReactiveStreamsFactory
 */
public static ReactiveStreamsEngine instance() {
    if (instance == null) {
        synchronized (ReactiveStreamsEngineResolver.class) {
            if (instance != null) {
                return instance;
            }

            ClassLoader cl = AccessController.doPrivileged((PrivilegedAction<ClassLoader>) () -> Thread.currentThread().getContextClassLoader());
            if (cl == null) {
                cl = ReactiveStreamsEngine.class.getClassLoader();
            }

            ReactiveStreamsEngine newInstance = loadFromSpi(cl);

            if (newInstance == null) {
                throw new IllegalStateException(
                    "No ReactiveStreamsEngine implementation found!");
            }

            instance = newInstance;
        }
    }

    return instance;
}
 

/**
 * @return the reactive stream engine. It uses {@link ServiceLoader#load(Class)} to find an implementation from the
 *         Classpath.
 * @throws IllegalStateException if no implementations are found.
 */
@Produces
@ApplicationScoped
public ReactiveStreamsEngine getEngine() {
    Iterator<ReactiveStreamsEngine> iterator = ServiceLoader.load(ReactiveStreamsEngine.class).iterator();
    if (iterator.hasNext()) {
        return iterator.next();
    }
    throw new IllegalStateException("No implementation of the "
            + ReactiveStreamsEngine.class.getName() + " found in the Classpath");
}
 

@BuildStep
public void build(BuildProducer<ServiceProviderBuildItem> serviceProvider,
        BuildProducer<FeatureBuildItem> feature) {
    feature.produce(new FeatureBuildItem(Feature.SMALLRYE_REACTIVE_STREAMS_OPERATORS));
    serviceProvider.produce(new ServiceProviderBuildItem(ReactiveStreamsEngine.class.getName(), Engine.class.getName()));
    serviceProvider.produce(new ServiceProviderBuildItem(ReactiveStreamsFactory.class.getName(),
            ReactiveStreamsFactoryImpl.class.getName()));
}
 

@BuildStep
public void build(BuildProducer<ServiceProviderBuildItem> serviceProvider) {
    serviceProvider
            .produce(new ServiceProviderBuildItem(ReactiveStreamsEngine.class.getName(), Engine.class.getName()));
    serviceProvider.produce(new ServiceProviderBuildItem(ReactiveStreamsFactory.class.getName(),
            ReactiveStreamsFactoryImpl.class.getName()));
}
 

public ReactiveStreamsSpiVerification(TestEnvironment testEnvironment, ReactiveStreamsFactory rs,
    ReactiveStreamsEngine engine, ScheduledExecutorService executorService) {
    this.testEnvironment = testEnvironment;
    this.rs = rs;
    this.engine = engine;
    this.executorService = executorService;
}
 

ReactiveStreamsEngine engine() {
    return engine;
}
 

@Override
protected ReactiveStreamsEngine createEngine() {
    return engine;
}
 

ReactiveStreamsEngine getEngine() {
    return engine;
}
 

@Override
public Publisher<T> buildRs(ReactiveStreamsEngine engine) {
    Objects.requireNonNull(engine, "Engine must not be null");
    return engine.buildPublisher(toGraph());
}
 

@Override
public CompletionSubscriber<T, R> build(ReactiveStreamsEngine engine) {
    Objects.requireNonNull(engine, "Engine must not be null");
    SubscriberWithCompletionStage<T, R> subscriberWithCompletionStage = engine.buildSubscriber(toGraph());
    return CompletionSubscriber.of(subscriberWithCompletionStage.getSubscriber(), subscriberWithCompletionStage.getCompletion());
}
 

@Override
public Processor<T, R> buildRs(ReactiveStreamsEngine engine) {
    Objects.requireNonNull(engine, "Engine must not be null");
    return engine.buildProcessor(toGraph());
}
 

@Override
public CompletionStage<T> run(ReactiveStreamsEngine engine) {
    Objects.requireNonNull(engine, "Engine must not be null");
    return engine.buildCompletion(toGraph());
}
 

/**
 * Build this stream, using the supplied {@link ReactiveStreamsEngine}.
 *
 * @param engine The engine to run the stream with.
 * @return A {@link CompletionSubscriber} that will run this stream.
 */
CompletionSubscriber<T, R> build(ReactiveStreamsEngine engine);
 

/**
 * Set the instance. It is used by OSGi environment while service loader
 * pattern is not supported.
 *
 * @param factory set the instance.
 */
public static void setInstance(ReactiveStreamsEngine factory) {
    instance = factory;
}
 

/**
 * Build this stream, using the supplied {@link ReactiveStreamsEngine}.
 *
 * @param engine The engine to run the stream with.
 * @return A {@link Publisher} that will run this stream.
 */
Publisher<T> buildRs(ReactiveStreamsEngine engine);
 

/**
 * Build this stream, using the supplied {@link ReactiveStreamsEngine}.
 *
 * @param engine The engine to run the stream with.
 * @return A {@link Processor} that will run this stream.
 */
Processor<T, R> buildRs(ReactiveStreamsEngine engine);
 

/**
 * Run this stream, using the supplied {@code ReactiveStreamsEngine}.
 *
 * @param engine The engine to run the stream with.
 * @return A completion stage that will be redeemed with the result of the stream, or an error if the stream fails.
 */
CompletionStage<T> run(ReactiveStreamsEngine engine);