## Uses of Interface
com.hazelcast.jet.function.DistributedSupplier

- Packages that use DistributedSupplier
  Package | Description
  --- | ---
  com.hazelcast.jet.aggregate | Contains `AggregateOperation` and several its variants, as well as a builder object for the aggregate operations.
  com.hazelcast.jet.avro | Apache Avro file read/write support for Hazelcast Jet.
  com.hazelcast.jet.core | Jet's Core API.
  com.hazelcast.jet.core.processor | Contains static utility classes with factories of Jet processors.
  com.hazelcast.jet.core.test | Utilities for writing tests of Core API Processors.
  com.hazelcast.jet.pipeline | The Pipeline API is Jet's high-level API to build and execute distributed computation jobs.

- - ### Uses of DistributedSupplier in com.hazelcast.jet.aggregate

    Methods in com.hazelcast.jet.aggregate that return DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `DistributedSupplier<A>` | AggregateOperation.`createFn()` A primitive that returns a new accumulator.

    Methods in com.hazelcast.jet.aggregate with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static <T,K,R,A,M extends Map<K,R>> AggregateOperation1<T,Map<K,A>,M>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn, DistributedSupplier<M> createMapFn, AggregateOperation1<? super T,A,R> downstream)` Returns an `AggregateOperation1` that accumulates the items into a `Map` (as obtained from `createMapFn`) where the key is the result of applying `keyFn` and the value is the result of applying the downstream aggregate operation to the items with that key.
    `static <T,C extends Collection<T>> AggregateOperation1<T,C,C>` | AggregateOperations.`toCollection(DistributedSupplier<C> createCollectionFn)` Returns an aggregate operation that accumulates the items into a `Collection`.
    `static <T,K,U,M extends Map<K,U>> AggregateOperation1<T,M,M>` | AggregateOperations.`toMap(DistributedFunction<? super T,? extends K> keyFn, DistributedFunction<? super T,? extends U> valueFn, DistributedBinaryOperator<U> mergeFn, DistributedSupplier<M> createMapFn)` Returns an `AggregateOperation1` that accumulates elements into a `Map` whose keys and values are the result of applying the provided mapping functions to the input elements.
    `static <A> AggregateOperationBuilder<A>` | AggregateOperation.`withCreate(DistributedSupplier<A> createFn)` Returns a builder object, initialized with the supplied `create` primitive, that can be used to construct the definition of an aggregate operation in a step-by-step manner.

  - ### Uses of DistributedSupplier in com.hazelcast.jet.avro

    Methods in com.hazelcast.jet.avro with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static Sink<org.apache.avro.generic.IndexedRecord>` | AvroSinks.`files(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier)` Convenience for `AvroSinks.files(String, DistributedSupplier, DistributedSupplier)` which uses `GenericDatumWriter`.
    `static <R> Sink<R>` | AvroSinks.`files(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier, Class<R> recordClass)` Convenience for `AvroSinks.files(String, DistributedSupplier, DistributedSupplier)` which uses either `SpecificDatumWriter` or `ReflectDatumWriter` depending on the supplied `recordClass`.
    `static <R> Sink<R>` | AvroSinks.`files(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier, DistributedSupplier<org.apache.avro.io.DatumWriter<R>> datumWriterSupplier)` Returns a sink that that writes the items it receives to Apache Avro files.
    `static <R> Sink<R>` | AvroSinks.`files(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier, DistributedSupplier<org.apache.avro.io.DatumWriter<R>> datumWriterSupplier)` Returns a sink that that writes the items it receives to Apache Avro files.
    `static <D> AvroSourceBuilder<D>` | AvroSources.`filesBuilder(String directory, DistributedSupplier<? extends org.apache.avro.io.DatumReader<D>> datumReaderSupplier)` Returns a builder object that offers a step-by-step fluent API to build a custom Avro file source for the Pipeline API.
    `static <D,T> ProcessorMetaSupplier` | AvroProcessors.`readFilesP(String directory, String glob, boolean sharedFileSystem, DistributedSupplier<? extends org.apache.avro.io.DatumReader<D>> datumReaderSupplier, DistributedBiFunction<String,? super D,T> mapOutputFn)` Returns a supplier of processors for `AvroSources.filesBuilder(java.lang.String, java.lang.Class<D>)`.
    `static <D> ProcessorMetaSupplier` | AvroProcessors.`writeFilesP(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier, DistributedSupplier<org.apache.avro.io.DatumWriter<D>> datumWriterSupplier)` Returns a supplier of processors for `AvroSinks.files(java.lang.String, com.hazelcast.jet.function.DistributedSupplier<org.apache.avro.Schema>, com.hazelcast.jet.function.DistributedSupplier<org.apache.avro.io.DatumWriter<R>>)`.
    `static <D> ProcessorMetaSupplier` | AvroProcessors.`writeFilesP(String directoryName, DistributedSupplier<org.apache.avro.Schema> schemaSupplier, DistributedSupplier<org.apache.avro.io.DatumWriter<D>> datumWriterSupplier)` Returns a supplier of processors for `AvroSinks.files(java.lang.String, com.hazelcast.jet.function.DistributedSupplier<org.apache.avro.Schema>, com.hazelcast.jet.function.DistributedSupplier<org.apache.avro.io.DatumWriter<R>>)`.

  - ### Uses of DistributedSupplier in com.hazelcast.jet.core

    Methods in com.hazelcast.jet.core that return DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static DistributedSupplier<WatermarkPolicy>` | WatermarkPolicies.`limitingLag(long lag)` Maintains a watermark that lags behind the top observed timestamp by the given amount.
    `static DistributedSupplier<WatermarkPolicy>` | WatermarkPolicies.`limitingLagAndDelay(long lag, long maxDelayMs)` Maintains a watermark that lags behind the top observed timestamp by at most the given amount and is additionally guaranteed to reach the timestamp of any given event within `maxDelayMs` of system time after observing it.
    `static DistributedSupplier<WatermarkPolicy>` | WatermarkPolicies.`limitingLagAndLull(long lag, long maxLullMs)` Maintains watermark that lags behind the top timestamp by the amount specified with `lag`.
    `static DistributedSupplier<WatermarkPolicy>` | WatermarkPolicies.`limitingTimestampAndWallClockLag(long timestampLag, long wallClockLag)` Maintains watermark that lags behind the top timestamp by at most `timestampLag` and behind wall-clock time by at most `wallClockLag`.
    `DistributedSupplier<? extends WatermarkPolicy>` | WatermarkGenerationParams.`newWmPolicyFn()` Returns the factory of the watermark policy objects.

    Methods in com.hazelcast.jet.core with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `Vertex` | DAG.`newVertex(String name, DistributedSupplier<? extends Processor> simpleSupplier)` Creates a vertex from a `Supplier<Processor>` and adds it to this DAG.
    `static ProcessorSupplier` | ProcessorSupplier.`of(DistributedSupplier<? extends Processor> processorSupplier)` Returns a `ProcessorSupplier` which will delegate to the given `Supplier<Processor>` to create all `Processor` instances.
    `static ProcessorMetaSupplier` | ProcessorMetaSupplier.`of(DistributedSupplier<? extends Processor> procSupplier)` Factory method that wraps the given `Supplier<Processor>` and uses it as the supplier of all `Processor` instances.
    `static ProcessorMetaSupplier` | ProcessorMetaSupplier.`of(DistributedSupplier<? extends Processor> procSupplier, int preferredLocalParallelism)` Factory method that wraps the given `Supplier<Processor>` and uses it as the supplier of all `Processor` instances.
    `static ProcessorMetaSupplier` | ProcessorMetaSupplier.`preferLocalParallelismOne(DistributedSupplier<? extends Processor> procSupplier)` Variant of `ProcessorMetaSupplier.preferLocalParallelismOne(ProcessorSupplier)` where the supplied `DistributedSupplier<Processor>` will be wrapped into a `ProcessorSupplier`.
    `static <T> WatermarkGenerationParams<T>` | WatermarkGenerationParams.`wmGenParams(DistributedToLongFunction<? super T> timestampFn, DistributedObjLongBiFunction<? super T,?> wrapFn, DistributedSupplier<? extends WatermarkPolicy> newWmPolicyFn, WatermarkEmissionPolicy wmEmitPolicy, long idleTimeoutMillis)` Creates and returns new watermark generation parameters.
    `static <T> WatermarkGenerationParams<T>` | WatermarkGenerationParams.`wmGenParams(DistributedToLongFunction<? super T> timestampFn, DistributedSupplier<? extends WatermarkPolicy> wmPolicy, WatermarkEmissionPolicy wmEmitPolicy, long idleTimeoutMillis)` Creates and returns a watermark generation parameters object.

    Constructors in com.hazelcast.jet.core with parameters of type DistributedSupplier
    Constructor and Description
    `Vertex(String name, DistributedSupplier<? extends Processor> processorSupplier)` Creates a vertex from a `Supplier<Processor>`.

  - ### Uses of DistributedSupplier in com.hazelcast.jet.core.processor

    Methods in com.hazelcast.jet.core.processor that return DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static <K,A> DistributedSupplier<Processor>` | Processors.`accumulateByFrameP(List<DistributedFunction<?,? extends K>> keyFns, List<DistributedToLongFunction<?>> timestampFns, TimestampKind timestampKind, SlidingWindowPolicy winPolicy, AggregateOperation<A,?> aggrOp)` Returns a supplier of processors for the first-stage vertex in a two-stage sliding window aggregation setup (see the `class Javadoc` for an explanation of aggregation stages).
    `static <K,A> DistributedSupplier<Processor>` | Processors.`accumulateByKeyP(List<DistributedFunction<?,? extends K>> getKeyFns, AggregateOperation<A,?> aggrOp)` Returns a supplier of processors for the first-stage vertex in a two-stage group-and-aggregate setup.
    `static <A,R> DistributedSupplier<Processor>` | Processors.`accumulateP(AggregateOperation<A,R> aggrOp)` Returns a supplier of processors for a vertex that performs the provided aggregate operation on all the items it receives.
    `static <K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`aggregateByKeyP(List<DistributedFunction<?,? extends K>> keyFns, AggregateOperation<A,R> aggrOp, DistributedBiFunction<? super K,? super R,OUT> mapToOutputFn)` Returns a supplier of processors for a vertex that groups items by key and performs the provided aggregate operation on each group.
    `static <A,R> DistributedSupplier<Processor>` | Processors.`aggregateP(AggregateOperation<A,R> aggrOp)` Returns a supplier of processors for a vertex that performs the provided aggregate operation on all the items it receives.
    `static <K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`aggregateToSessionWindowP(long sessionTimeout, List<DistributedToLongFunction<?>> timestampFns, List<DistributedFunction<?,? extends K>> keyFns, AggregateOperation<A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)` Returns a supplier of processors for a vertex that aggregates events into session windows.
    `static <K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`aggregateToSlidingWindowP(List<DistributedFunction<?,? extends K>> keyFns, List<DistributedToLongFunction<?>> timestampFns, TimestampKind timestampKind, SlidingWindowPolicy winPolicy, AggregateOperation<A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)` Returns a supplier of processors for a vertex that aggregates events into a sliding window in a single stage (see the `class Javadoc` for an explanation of aggregation stages).
    `static <K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`combineByKeyP(AggregateOperation<A,R> aggrOp, DistributedBiFunction<? super K,? super R,OUT> mapToOutputFn)` Returns a supplier of processors for the second-stage vertex in a two-stage group-and-aggregate setup.
    `static <A,R> DistributedSupplier<Processor>` | Processors.`combineP(AggregateOperation<A,R> aggrOp)` Returns a supplier of processors for a vertex that performs the provided aggregate operation on all the items it receives.
    `static <K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`combineToSlidingWindowP(SlidingWindowPolicy winPolicy, AggregateOperation<A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)` Returns a supplier of processors for the second-stage vertex in a two-stage sliding window aggregation setup (see the `class Javadoc` for an explanation of aggregation stages).
    `static <T> DistributedSupplier<Processor>` | Processors.`filterP(DistributedPredicate<T> filterFn)` Returns a supplier of processors for a vertex that emits the same items it receives, but only those that pass the given predicate.
    `static <T,R> DistributedSupplier<Processor>` | Processors.`flatMapP(DistributedFunction<T,? extends Traverser<? extends R>> flatMapFn)` Returns a supplier of processors for a vertex that applies the provided item-to-traverser mapping function to each received item and emits all the items from the resulting traverser.
    `static <T> DistributedSupplier<Processor>` | Processors.`insertWatermarksP(WatermarkGenerationParams<? super T> wmGenParams)` Returns a supplier of processors for a vertex that inserts `watermark items` into the stream.
    `static <T,R> DistributedSupplier<Processor>` | Processors.`mapP(DistributedFunction<T,R> mapFn)` Returns a supplier of processors for a vertex which, for each received item, emits the result of applying the given mapping function to it.
    `static DistributedSupplier<Processor>` | Processors.`noopP()` Returns a supplier of processor that swallows all its input (if any) and does nothing with it and produces no output.
    `static <T> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekInputP(DistributedFunction<T,? extends CharSequence> toStringFn, DistributedPredicate<T> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekInput(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekInputP(DistributedSupplier<Processor> wrapped)` Convenience for `peekInput(toStringFn, shouldLogFn, metaSupplier)` with a pass-through filter and `Object#toString` as the formatting function.
    `static <T> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekOutputP(DistributedFunction<? super T,? extends CharSequence> toStringFn, DistributedPredicate<? super T> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekOutput(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekOutputP(DistributedSupplier<Processor> wrapped)` Convenience for `peekOutput(toStringFn, shouldLogFn, metaSupplier` with a pass-through filter and `Object#toString` as the formatting function.
    `static <K,V> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekSnapshotP(DistributedFunction<? super Map.Entry<K,V>,? extends CharSequence> toStringFn, DistributedPredicate<? super Map.Entry<K,V>> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekSnapshot(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekSnapshotP(DistributedSupplier<Processor> wrapped)` Convenience for `peekSnapshot(toStringFn, shouldLogFn, metaSupplier` with a pass-through filter and `Object#toString` as the formatting function.
    `static <T,K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`rollingAggregateP(DistributedFunction<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,? extends R> aggrOp, DistributedTriFunction<? super T,? super K,? super R,? extends OUT> mapToOutputFn)` Returns a supplier of processors for a vertex that performs a rolling aggregation.
    `static <W,T> DistributedSupplier<Processor>` | SinkProcessors.`writeBufferedP(DistributedFunction<? super Processor.Context,? extends W> createFn, DistributedBiConsumer<? super W,? super T> onReceiveFn, DistributedConsumer<? super W> flushFn)` Shortcut for `SinkProcessors.writeBufferedP(DistributedFunction, DistributedBiConsumer, DistributedConsumer, DistributedConsumer)` with a no-op `destroyFn`.
    `static <W,T> DistributedSupplier<Processor>` | SinkProcessors.`writeBufferedP(DistributedFunction<? super Processor.Context,? extends W> createFn, DistributedBiConsumer<? super W,? super T> onReceiveFn, DistributedConsumer<? super W> flushFn, DistributedConsumer<? super W> destroyFn)` Returns a supplier of processors for a vertex that drains all the items from the inbox to an internal writer object and then does a flush.

    Methods in com.hazelcast.jet.core.processor with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static <T> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekInputP(DistributedFunction<T,? extends CharSequence> toStringFn, DistributedPredicate<T> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekInput(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekInputP(DistributedSupplier<Processor> wrapped)` Convenience for `peekInput(toStringFn, shouldLogFn, metaSupplier)` with a pass-through filter and `Object#toString` as the formatting function.
    `static <T> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekOutputP(DistributedFunction<? super T,? extends CharSequence> toStringFn, DistributedPredicate<? super T> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekOutput(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekOutputP(DistributedSupplier<Processor> wrapped)` Convenience for `peekOutput(toStringFn, shouldLogFn, metaSupplier` with a pass-through filter and `Object#toString` as the formatting function.
    `static <K,V> DistributedSupplier<Processor>` | DiagnosticProcessors.`peekSnapshotP(DistributedFunction<? super Map.Entry<K,V>,? extends CharSequence> toStringFn, DistributedPredicate<? super Map.Entry<K,V>> shouldLogFn, DistributedSupplier<Processor> wrapped)` Same as `peekSnapshot(toStringFn, shouldLogFn, metaSupplier)`, but accepts a `DistributedSupplier` of processors instead of a meta-supplier.
    `static DistributedSupplier<Processor>` | DiagnosticProcessors.`peekSnapshotP(DistributedSupplier<Processor> wrapped)` Convenience for `peekSnapshot(toStringFn, shouldLogFn, metaSupplier` with a pass-through filter and `Object#toString` as the formatting function.
    `static <T> ProcessorMetaSupplier` | SourceProcessors.`readJdbcP(DistributedSupplier<? extends Connection> connectionSupplier, ToResultSetFunction resultSetFn, DistributedFunction<? super ResultSet,? extends T> mapOutputFn)` Returns a supplier of processors for `Sources.jdbc( DistributedSupplier, ToResultSetFunction, DistributedFunction)`.
    `static <T> ProcessorMetaSupplier` | SourceProcessors.`streamJmsQueueP(DistributedSupplier<? extends javax.jms.Connection> connectionSupplier, DistributedFunction<? super javax.jms.Connection,? extends javax.jms.Session> sessionFn, DistributedFunction<? super javax.jms.Session,? extends javax.jms.MessageConsumer> consumerFn, DistributedConsumer<? super javax.jms.Session> flushFn, DistributedFunction<? super javax.jms.Message,? extends T> projectionFn)` Returns a supplier of processors for `Sources.jmsQueueBuilder(com.hazelcast.jet.function.DistributedSupplier<? extends javax.jms.ConnectionFactory>)`.
    `static <T> ProcessorMetaSupplier` | SourceProcessors.`streamJmsTopicP(DistributedSupplier<? extends javax.jms.Connection> connectionSupplier, DistributedFunction<? super javax.jms.Connection,? extends javax.jms.Session> sessionFn, DistributedFunction<? super javax.jms.Session,? extends javax.jms.MessageConsumer> consumerFn, DistributedConsumer<? super javax.jms.Session> flushFn, DistributedFunction<? super javax.jms.Message,? extends T> projectionFn)` Returns a supplier of processors for `Sources.jmsTopicBuilder(com.hazelcast.jet.function.DistributedSupplier<? extends javax.jms.ConnectionFactory>)`.
    `static <T> ProcessorMetaSupplier` | SinkProcessors.`writeJdbcP(String updateQuery, DistributedSupplier<? extends Connection> connectionSupplier, DistributedBiConsumer<? super PreparedStatement,? super T> bindFn)` Returns a supplier of processors for `Sinks.jdbc(String, DistributedSupplier, DistributedBiConsumer)`.
    `static <T> ProcessorMetaSupplier` | SinkProcessors.`writeJmsQueueP(DistributedSupplier<? extends javax.jms.Connection> connectionSupplier, DistributedFunction<? super javax.jms.Connection,? extends javax.jms.Session> sessionF, DistributedBiFunction<? super javax.jms.Session,? super T,? extends javax.jms.Message> messageFn, DistributedBiConsumer<? super javax.jms.MessageProducer,? super javax.jms.Message> sendFn, DistributedConsumer<? super javax.jms.Session> flushFn, String name)` Returns a supplier of processors for `Sinks.jmsQueueBuilder(com.hazelcast.jet.function.DistributedSupplier<javax.jms.ConnectionFactory>)`.
    `static <T> ProcessorMetaSupplier` | SinkProcessors.`writeJmsTopicP(DistributedSupplier<? extends javax.jms.Connection> connectionSupplier, DistributedFunction<? super javax.jms.Connection,? extends javax.jms.Session> sessionF, DistributedBiFunction<? super javax.jms.Session,? super T,? extends javax.jms.Message> messageFn, DistributedBiConsumer<? super javax.jms.MessageProducer,? super javax.jms.Message> sendFn, DistributedConsumer<? super javax.jms.Session> flushFn, String name)` Returns a supplier of processors for `Sinks.jmsTopicBuilder(com.hazelcast.jet.function.DistributedSupplier<javax.jms.ConnectionFactory>)`.

  - ### Uses of DistributedSupplier in com.hazelcast.jet.core.test

    Methods in com.hazelcast.jet.core.test with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `static TestSupport` | TestSupport.`verifyProcessor(DistributedSupplier<Processor> supplier)`

  - ### Uses of DistributedSupplier in com.hazelcast.jet.pipeline

    Methods in com.hazelcast.jet.pipeline with parameters of type DistributedSupplier
    Modifier and Type | Method and Description
    --- | ---
    `<R> StreamStage<R>` | StreamStage.`customTransform(String stageName, DistributedSupplier<Processor> procSupplier)`
    `<R> GeneralStage<R>` | GeneralStage.`customTransform(String stageName, DistributedSupplier<Processor> procSupplier)` Attaches a stage with a custom transform based on the provided supplier of Core API `Processor`s.
    `<R> BatchStage<R>` | BatchStage.`customTransform(String stageName, DistributedSupplier<Processor> procSupplier)`
    `static <T> BatchSource<T>` | Sources.`jdbc(DistributedSupplier<? extends Connection> connectionSupplier, ToResultSetFunction resultSetFn, DistributedFunction<? super ResultSet,? extends T> createOutputFn)` Returns a source which connects to the specified database using the given `connectionSupplier`, queries the database and creates a result set using the the given `resultSetFn`.
    `static <T> Sink<T>` | Sinks.`jdbc(String updateQuery, DistributedSupplier<Connection> connectionSupplier, DistributedBiConsumer<PreparedStatement,T> bindFn)` Returns a sink that connects to the specified database using the given `connectionSupplier`, prepares a statement using the given `updateQuery` and inserts/updates the items.
    `static StreamSource<javax.jms.Message>` | Sources.`jmsQueue(DistributedSupplier<? extends javax.jms.ConnectionFactory> factorySupplier, String name)` Convenience for `Sources.jmsQueueBuilder(DistributedSupplier)`.
    `static <T> Sink<T>` | Sinks.`jmsQueue(DistributedSupplier<javax.jms.ConnectionFactory> factorySupplier, String name)` Convenience for `Sinks.jmsQueueBuilder(DistributedSupplier)`.
    `static JmsSourceBuilder` | Sources.`jmsQueueBuilder(DistributedSupplier<? extends javax.jms.ConnectionFactory> factorySupplier)` Returns a builder object that offers a step-by-step fluent API to build a custom JMS `StreamSource` for the Pipeline API.
    `static <T> JmsSinkBuilder<T>` | Sinks.`jmsQueueBuilder(DistributedSupplier<javax.jms.ConnectionFactory> factorySupplier)` Returns a builder object that offers a step-by-step fluent API to build a custom JMS queue sink for the Pipeline API.
    `static StreamSource<javax.jms.Message>` | Sources.`jmsTopic(DistributedSupplier<? extends javax.jms.ConnectionFactory> factorySupplier, String name)` Convenience for `Sources.jmsTopicBuilder(DistributedSupplier)`.
    `static <T> Sink<T>` | Sinks.`jmsTopic(DistributedSupplier<javax.jms.ConnectionFactory> factorySupplier, String name)` Convenience for `Sinks.jmsTopicBuilder(DistributedSupplier)`.
    `static JmsSourceBuilder` | Sources.`jmsTopicBuilder(DistributedSupplier<? extends javax.jms.ConnectionFactory> factorySupplier)` Returns a builder object that offers a step-by-step fluent API to build a custom JMS `StreamSource` for the Pipeline API.
    `static <T> JmsSinkBuilder<T>` | Sinks.`jmsTopicBuilder(DistributedSupplier<javax.jms.ConnectionFactory> factorySupplier)` Returns a builder object that offers a step-by-step fluent API to build a custom JMS topic sink for the Pipeline API.

Copyright © 2018. All rights reserved.