/** This class contains all logical related to process records from single input. */
public interface OneInputStreamProcessFunction<IN, OUT> extends ProcessFunction {
    /**
 * This interface represents *the Processcontext recordassociated andwith emitall dataoperations throughmust {@link Collector}.
     *
     * @param record to process.be applied to all
 * partitions.
 */ 
public interface NonPartitionedContext<OUT> extends RuntimeContext {
    /**
     * @paramApply a outputfunction to emit processed records. all partitions. For keyed stream, it will apply to all keys. For
     * @paramnon-keyed ctxstream, runtimeit contextwill inapply whichto this function is executedsingle partition.
     */
    void processRecordapplyToAllPartitions(IN record, Collector<OUT> output, RuntimeContext ctx) throws Exception;

    ApplyPartitionFunction<OUT> applyPartitionFunction);
}

/**
 A function to be *applied Thisto isall apartitions life-cycle method indicates that this function will no longer receive any input. */
@FunctionalInterface
public interface ApplyPartitionFunction<OUT> {
    /**
     * data.The This allowing the ProcessFunctionactual method to emitbe results at once rather than upon each recordapplied to each partition.
     *
     * @param outputcollector to emitoutput recorddata.
     * @param ctx, runtime context in which this function is executed.
     */
    default void endInputapply(Collector<OUT> outputcollector, RuntimeContext ctx) {throws Exception;
}
}

    /**
 This class contains all logical *related Thisto isprocess a life-cycle method indicates that this function will no longer receive any data fromrecords from single input. */
public interface OneInputStreamProcessFunction<IN, OUT> extends ProcessFunction {
    /**
     * theProcess firstrecord input.and Thisemit allowingdata thethrough ProcessFunction to emit results at once rather than upon{@link Collector}.
     *
     * each@param record.
     *to process.
     * @param output to emit processed recordrecords.
     * @param ctx, runtime context in which this function is executed.
     */
    default void endFirstInputprocessRecord(IN record, Collector<OUT> output, RuntimeContext ctx) throws {}Exception;

    /**
     * This is a life-cycle method indicates that this function will no longer receive any data frominput
     * thedata.
 second input. This allowing the ProcessFunction to emit results at once rather than upon
     * each record.
     *
     * @param output to emit record.
     * @param ctx, runtimethe context in which this function is executed.
     */
    default void endSecondInputendInput(Collector<OUT>NonPartitionedContext<OUT> output, RuntimeContext ctx) {}
}

/**
 * This class contains all logical related to process records from a broadcast stream and a
 * non-broadcast stream.
 */
public interface TwoInputBroadcastStreamProcessFunction<IN1, IN2, OUT> extends ProcessFunction {
    /**
     * Process record from non-broadcast input and emit data through {@link Collector}.
     *
     * @param record to process.
     * @param output to emit processed records.
     * @param ctx, runtime context in which this function is executed.
     */
    void processRecordFromNonBroadcastInput(IN1 record, Collector<OUT> output, RuntimeContext ctx)
            throws Exception;

    /**
     * Process record from broadcast input.In general, the broadcast side is not allowed to
     * manipulate state and output data because it corresponds to all partitions instead of a single
     * partition. But you could use broadcast context to process all the partitions at once.
     *
     * @param record to process.
     * @param ctx, the context in which this function is executed.
     */
    void processRecordFromBroadcastInput(IN2 record, NonPartitionedContext<OUT> ctx) throws Exception;

    /**
     * This is a life-cycle method indicates that this function will no longer receive any data from
     * the non-broadcast input.
     *
     * @param ctx, the context in which this function is executed.
     */
    default void endNonBroadcastInput(NonPartitionedContext<OUT> ctx) {}

    /**
     * This is a life-cycle method indicates that this function will no longer receive any data from
     * the broadcast input.
     *
     * @param ctx, the context in which this function is executed.
     */
    default void endBroadcastInput(NonPartitionedContext<OUT> ctx) {}
}

/** This class contains all logical related to process and emit records to two outputs. */
public interface TwoOutputStreamProcessFunction<IN, OUT1, OUT2> extends ProcessFunction {
    /**
     * Process and emit record to the first/second output through {@link Collector}s.
     *
     * @param record to process.
     * @param output1 to emit processed records to the first output.
     * @param output2 to emit processed records to the second output.
     * @param ctx, runtime context in which this function is executed.
     */
    void processRecord(
            IN record, Collector<OUT1> output1, Collector<OUT2> output2, RuntimeContext ctx);

   /**
     * This is a life-cycle method indicates that this function will no longer receive any input
     * data.
     *
     * @param ctx, the context in which this function is executed.
     */
    default void endInput(TwoOutputNonPartitionedContext<OUT1, OUT2> ctx) {}
}

/**
 * This class represents a kind of partitioned data stream. For this stream, each parallelism is a
 * partition, and the partition to which the data belongs is random.
 */
public interface NonKeyedPartitionStream<T> {
    /**
     * Apply an operation to this {@link NonKeyedPartitionStream};
     *
     * @param processFunction to perform operation.
     * @return new stream with this operation.
     */
    <OUT> NonKeyedPartitionStream<OUT> process(
            OneInputStreamProcessFunction<T, OUT> processFunction);

    /**
     * Apply a two output operation to this {@link NonKeyedPartitionStream}.
     *
     * @param processFunction to perform two output operation.
     * @return new stream with this operation.
     */
    <OUT1, OUT2> TwoNonKeyedPartitionStreams<OUT1, OUT2> process(
            TwoOutputStreamProcessFunction<T, OUT1, OUT2> processFunction);

    /**
     * Apply to a two input operation on this and other {@link NonKeyedPartitionStream}.
     *
     * @param other {@link NonKeyedPartitionStream} to perform operation with two input.
     * @param processFunction to perform operation.
     * @return new stream with this operation.
     */
    <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
            NonKeyedPartitionStream<T_OTHER> other,
            TwoInputNonBroadcastStreamProcessFunction<T, T_OTHER, OUT> processFunction);

    /**
     * Apply a two input operation to this and other {@link BroadcastStream}.
     *
     * @param processFunction to perform operation.
     * @return new stream with this operation.
     */
    <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
            BroadcastStream<T_OTHER> other,
            TwoInputBroadcastStreamProcessFunction<T, T_OTHER, OUT> processFunction);

    /**
     * Coalesce this stream to a {@link GlobalStream}.
     *
     * @return the coalesced global stream.
     */
    GlobalStream<T> global();

/**
 * This class represents a kind of partitioned data stream. For this stream, each parallelism is a
 * partition, and the partition to which the data belongs is random.
 */
public interface NonKeyedPartitionStream<T> {
    /**
     * ApplyTransform anthis operationstream to thisa {@link NonKeyedPartitionStreamKeyedPartitionStream};.
     *
     * @param processFunctionkeySelector to decide how to map performdata to operationpartition.
     * @return new stream with this operation. the transformed stream partitioned by key.
     */
    <K> KeyedPartitionStream<K, T> keyBy(KeySelector<T, K> keySelector);

    /**
     */
 Transform this stream <OUT>to NonKeyedPartitionStream<OUT>a process(
new {@link NonKeyedPartitionStream}, data will be shuffled between
     OneInputStreamProcessFunction<T, OUT> processFunction);

* these two streams.
     /**
     * Apply@return athe twotransformed outputstream operation to this {@link NonKeyedPartitionStream}after shuffle.
     */
     * @param processFunction to perform two output operation.NonKeyedPartitionStream<T> shuffle();

    /**
     * @returnTransform newthis stream with this operationto a new {@link BroadcastStream}.
     */
    <OUT1, OUT2>* TwoNonKeyedPartitionStreams<OUT1,@return OUT2>the process(
transformed {@link BroadcastStream}.
     */
     TwoOutputStreamProcessFunction<T, OUT1, OUT2> processFunctionBroadcastStream<T> broadcast();

    /**
     * ApplySink todata a two input operation on this and other {@link NonKeyedPartitionStream}from this stream.
     *
     * @param other {@link NonKeyedPartitionStream} sink to performreceive operationdata withfrom twothis inputstream.
     */
  @param processFunction tovoid perform operation.toSink(Sink<T> sink);

     /**
 @return new stream with this* operation.
This class represents a combination */
of two {@link  <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(NonKeyedPartitionStream}. It will be used
     * as the return value of operation with NonKeyedPartitionStream<T_OTHER> other,two output.
     */
    interface TwoNonKeyedPartitionStreams<T1, T2> {
 TwoInputStreamProcessFunction<T, T_OTHER, OUT> processFunction);

    /**
 Get the first stream. */
 Apply a two input operation to this and other {@link BroadcastStream}.NonKeyedPartitionStream<T1> getFirst();

     *
     /** @param processFunctionGet tothe performsecond operationstream. */
     * @return new stream with this operation.NonKeyedPartitionStream<T2> getSecond();
    }
}

/**
 * This class represents a kind of partitioned data stream. For this stream, Each key group is a
 * partition, and the partition to which the data belongs is determined.
 */
public interface KeyedPartitionStream<K, T> { */
    <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
            BroadcastStream<T_OTHER> other,
            TwoInputStreamProcessFunction<T, T_OTHER, OUT> processFunction);

    /**
     * CoalesceApply thisan streamoperation to athis {@link GlobalStreamKeyedPartitionStream}.
     *
     * @return<p>This themethod coalescedis globalused stream.
to avoid shuffle after applying */
the process function. It GlobalStream<T> coalesce();

is required
     /**
 that for the same *record, Transformthe this stream to a new {@link KeyedPartitionStream}.
     *KeySelector} must extract the same key as the
     * @paramoriginal keySelector{@link toKeySelector} decideon how to map data to partitionthis {@link KeyedPartitionStream}.
     *
 @return the transformed stream partitioned* by@param key.
processFunction to    */perform operation.
    <K> KeyedPartitionStream<K,* T> keyBy(KeySelector<T, K> keySelector);

    /**@param newKeySelector to select the key after process.
     * Transform this stream to a@return new {@link NonKeyedPartitionStream}, data will be shuffled betweenKeyedPartitionStream} with this operation.
     */
    <OUT> * these two streams.
KeyedPartitionStream<K, OUT> process(
       *
     *OneInputStreamProcessFunction<T, @returnOUT> theprocessFunction,
 transformed stream after shuffle.
     */
   KeySelector<OUT, NonKeyedPartitionStream<T>K> shuffle(newKeySelector);

    /**
     * TransformApply thisan streamoperation to a newthis {@link BroadcastStreamKeyedPartitionStream}.;
     *
     * @return@param theprocessFunction transformedto {@linkperform BroadcastStream}operation.
     */
 @return new {@link BroadcastStream<T> broadcast();

    /**
     * Sink data from this streamNonKeyedPartitionStream} with this operation.
     */
    <OUT> * @param sink to receive data from this stream.
NonKeyedPartitionStream<OUT> process(
         */
    void toSink(Sink<T> sinkOneInputStreamProcessFunction<T, OUT> processFunction);

    /**
     * ThisApply classa representstwo aoutput combinationoperation ofto twothis {@link NonKeyedPartitionStreamKeyedPartitionStream}. It will be used
     *
 as the return value of* operation<p>This withmethod twois output.
used to avoid shuffle after */
applying the process function. interfaceIt TwoNonKeyedPartitionStreams<T1, T2> {is required
     * that for /**the Getsame therecord, firstthese stream. */
        NonKeyedPartitionStream<T1> getFirst();
new two {@link KeySelector}s must extract the same key as the
     * original  /** Get the second stream. */{@link KeySelector}s on this {@link KeyedPartitionStream}.
     *
     * @param processFunction NonKeyedPartitionStream<T2> getSecond();
    }
}

/** This class represents a stream that force single parallelism. */
public interface GlobalStream<T> {
    /**
     * TransformApply thisan streamoperation to a newthis {@link NonKeyedPartitionStreamGlobalStream},;
 data will be shuffled between*
     * @param theseprocessFunction to twoperform streamsoperation.
     * @return new stream with this operation.
     */
 @return the transformed stream<OUT> afterGlobalStream<OUT> shuffle.process(
     */
       OneInputStreamProcessFunction<T, NonKeyedPartitionStream<T>OUT> shuffle(processFunction);

    /**
     * Apply a Transformtwo thisoutput streamoperation to athis new {@link BroadcastStreamGlobalStream}.
     *
     * @return@param theprocessFunction transformedto {@link BroadcastStream}.
     */
    BroadcastStream<T> broadcast();

perform two output operation.
     /**
 @return new stream  * Sink data from with this streamoperation.
     */
    <OUT1, *OUT2> @paramTwoGlobalStream<OUT1, sinkOUT2> toprocess(
 receive data from this stream.
     */
   TwoOutputStreamProcessFunction<T, void toSink(Sink<T> sinkOUT1, OUT2> processFunction);

    /**
     * Apply Thisa two classinput representsoperation ato combinationthis ofand twoother {@link KeyedPartitionStreamGlobalStream}.
 It will be used as*
     * the return value of @param other {@link GlobalStream} to perform operation with two outputinput.
     */
 @param processFunction to interface TwoKeyedPartitionStreams<K, T1, T2> {
        /** Get the first stream.perform operation.
     * @return new stream with this operation.
     */
    <T_OTHER, OUT>   KeyedPartitionStream<K, T1> getFirst();

        /** Get the second stream. */
GlobalStream<OUT> connectAndProcess(
            GlobalStream<T_OTHER> KeyedPartitionStream<Kother,
 T2> getSecond();
    }
}

/** This class represents a stream that each parallel task processes the same data. */
public interface   NonKeyedPartitionStream<T> shuffle();

BroadcastStream<T> {
    /**
     * Transform this streamApply a two input operation to this aand newother {@link BroadcastStreamKeyedPartitionStream}.
     *
     * @return@param the transformedother {@link BroadcastStream}KeyedPartitionStream} to perform operation with two input.
     */
 @param processFunction to BroadcastStream<T> broadcast();

perform operation.
     /*** @return new stream with this operation.
     * Sink data from this stream./
    <K, T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
     *
     * @param sink to receive data from this stream.
KeyedPartitionStream<K, T_OTHER> other,
         */
    void toSink(Sink<T> sinkTwoInputBroadcastStreamProcessFunction<T, T_OTHER, OUT> processFunction);

     /**
     * Apply a Thistwo classinput representsoperation ato combinationthis ofand twoother {@link GlobalStreamNonKeyedPartitionStream}. It
 will be used as the*
     * return value of@param other {@link NonKeyedPartitionStream} to perform operation with two output.
     */
    interface TwoGlobalStream<T1, T2> {
  input.
     * /**@param GetprocessFunction theto firstperform streamoperation. */
     * @return new GlobalStream<T1> getFirst();

stream with this operation.
     */
   /** Get the second stream. */ <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
        GlobalStream<T2> getSecond();
   NonKeyedPartitionStream<T_OTHER> }
}