How to use

addOperator

method

in

org.apache.flink.streaming.api.environment.StreamExecutionEnvironment

/**
 * Method for passing user defined operators along with the type
 * information that will transform the DataStream.
 *
 * @param operatorName
 *            name of the operator, for logging purposes
 * @param outTypeInfo
 *            the output type of the operator
 * @param operator
 *            the object containing the transformation logic
 * @param <R>
 *            type of the return stream
 * @return the data stream constructed
 */
@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(
      this.transformation,
      operatorName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);
  getExecutionEnvironment().addOperator(resultTransform);
  return returnStream;
}

/**
 * Adds the given sink to this DataStream. Only streams with sinks added
 * will be executed once the {@link StreamExecutionEnvironment#execute()}
 * method is called.
 *
 * @param sinkFunction
 *            The object containing the sink's invoke function.
 * @return The closed DataStream.
 */
public DataStreamSink<T> addSink(SinkFunction<T> sinkFunction) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  // configure the type if needed
  if (sinkFunction instanceof InputTypeConfigurable) {
    ((InputTypeConfigurable) sinkFunction).setInputType(getType(), getExecutionConfig());
  }
  StreamSink<T> sinkOperator = new StreamSink<>(clean(sinkFunction));
  DataStreamSink<T> sink = new DataStreamSink<>(this, sinkOperator);
  getExecutionEnvironment().addOperator(sink.getTransformation());
  return sink;
}

SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, transform);
getExecutionEnvironment().addOperator(transform);

@Internal
private <OUT> SingleOutputStreamOperator<OUT> transform(
    final String functionName,
    final TypeInformation<OUT> outTypeInfo,
    final TwoInputStreamOperator<IN1, IN2, OUT> operator) {
  // read the output type of the input Transforms to coax out errors about MissingTypeInfo
  inputStream1.getType();
  inputStream2.getType();
  TwoInputTransformation<IN1, IN2, OUT> transform = new TwoInputTransformation<>(
      inputStream1.getTransformation(),
      inputStream2.getTransformation(),
      functionName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  if (inputStream1 instanceof KeyedStream) {
    KeyedStream<IN1, ?> keyedInput1 = (KeyedStream<IN1, ?>) inputStream1;
    TypeInformation<?> keyType1 = keyedInput1.getKeyType();
    transform.setStateKeySelectors(keyedInput1.getKeySelector(), null);
    transform.setStateKeyType(keyType1);
  }
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<OUT> returnStream = new SingleOutputStreamOperator(environment, transform);
  getExecutionEnvironment().addOperator(transform);
  return returnStream;
}

/**
 * Method for passing user defined operators along with the type
 * information that will transform the DataStream.
 *
 * @param operatorName
 *            name of the operator, for logging purposes
 * @param outTypeInfo
 *            the output type of the operator
 * @param operator
 *            the object containing the transformation logic
 * @param <R>
 *            type of the return stream
 * @return the data stream constructed
 */
@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(
      this.transformation,
      operatorName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);
  getExecutionEnvironment().addOperator(resultTransform);
  return returnStream;
}

/**
 * Method for passing user defined operators along with the type
 * information that will transform the DataStream.
 *
 * @param operatorName
 *            name of the operator, for logging purposes
 * @param outTypeInfo
 *            the output type of the operator
 * @param operator
 *            the object containing the transformation logic
 * @param <R>
 *            type of the return stream
 * @return the data stream constructed
 */
@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(
      this.transformation,
      operatorName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);
  getExecutionEnvironment().addOperator(resultTransform);
  return returnStream;
}

/**
 * Method for passing user defined operators along with the type
 * information that will transform the DataStream.
 *
 * @param operatorName
 *            name of the operator, for logging purposes
 * @param outTypeInfo
 *            the output type of the operator
 * @param operator
 *            the object containing the transformation logic
 * @param <R>
 *            type of the return stream
 * @return the data stream constructed
 */
@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(
      this.transformation,
      operatorName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);
  getExecutionEnvironment().addOperator(resultTransform);
  return returnStream;
}

keyedStream.getExecutionEnvironment().addOperator(rawFlinkTransform);

keyedStream.getExecutionEnvironment().addOperator(rawFlinkTransform);

/**
 * Adds the given sink to this DataStream. Only streams with sinks added
 * will be executed once the {@link StreamExecutionEnvironment#execute()}
 * method is called.
 *
 * @param sinkFunction
 *            The object containing the sink's invoke function.
 * @return The closed DataStream.
 */
public DataStreamSink<T> addSink(SinkFunction<T> sinkFunction) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  // configure the type if needed
  if (sinkFunction instanceof InputTypeConfigurable) {
    ((InputTypeConfigurable) sinkFunction).setInputType(getType(), getExecutionConfig());
  }
  StreamSink<T> sinkOperator = new StreamSink<>(clean(sinkFunction));
  DataStreamSink<T> sink = new DataStreamSink<>(this, sinkOperator);
  getExecutionEnvironment().addOperator(sink.getTransformation());
  return sink;
}

/**
 * Adds the given sink to this DataStream. Only streams with sinks added
 * will be executed once the {@link StreamExecutionEnvironment#execute()}
 * method is called.
 *
 * @param sinkFunction
 *            The object containing the sink's invoke function.
 * @return The closed DataStream.
 */
public DataStreamSink<T> addSink(SinkFunction<T> sinkFunction) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  // configure the type if needed
  if (sinkFunction instanceof InputTypeConfigurable) {
    ((InputTypeConfigurable) sinkFunction).setInputType(getType(), getExecutionConfig());
  }
  StreamSink<T> sinkOperator = new StreamSink<>(clean(sinkFunction));
  DataStreamSink<T> sink = new DataStreamSink<>(this, sinkOperator);
  getExecutionEnvironment().addOperator(sink.getTransformation());
  return sink;
}

/**
 * Adds the given sink to this DataStream. Only streams with sinks added
 * will be executed once the {@link StreamExecutionEnvironment#execute()}
 * method is called.
 *
 * @param sinkFunction
 *            The object containing the sink's invoke function.
 * @return The closed DataStream.
 */
public DataStreamSink<T> addSink(SinkFunction<T> sinkFunction) {
  // read the output type of the input Transform to coax out errors about MissingTypeInfo
  transformation.getOutputType();
  // configure the type if needed
  if (sinkFunction instanceof InputTypeConfigurable) {
    ((InputTypeConfigurable) sinkFunction).setInputType(getType(), getExecutionConfig());
  }
  StreamSink<T> sinkOperator = new StreamSink<>(clean(sinkFunction));
  DataStreamSink<T> sink = new DataStreamSink<>(this, sinkOperator);
  getExecutionEnvironment().addOperator(sink.getTransformation());
  return sink;
}

SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, transform);
getExecutionEnvironment().addOperator(transform);

SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, transform);
getExecutionEnvironment().addOperator(transform);

SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, transform);
getExecutionEnvironment().addOperator(transform);

@Internal
private <OUT> SingleOutputStreamOperator<OUT> transform(
    final String functionName,
    final TypeInformation<OUT> outTypeInfo,
    final TwoInputStreamOperator<IN1, IN2, OUT> operator) {
  // read the output type of the input Transforms to coax out errors about MissingTypeInfo
  inputStream1.getType();
  inputStream2.getType();
  TwoInputTransformation<IN1, IN2, OUT> transform = new TwoInputTransformation<>(
      inputStream1.getTransformation(),
      inputStream2.getTransformation(),
      functionName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  if (inputStream1 instanceof KeyedStream) {
    KeyedStream<IN1, ?> keyedInput1 = (KeyedStream<IN1, ?>) inputStream1;
    TypeInformation<?> keyType1 = keyedInput1.getKeyType();
    transform.setStateKeySelectors(keyedInput1.getKeySelector(), null);
    transform.setStateKeyType(keyType1);
  }
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<OUT> returnStream = new SingleOutputStreamOperator(environment, transform);
  getExecutionEnvironment().addOperator(transform);
  return returnStream;
}

@Internal
private <OUT> SingleOutputStreamOperator<OUT> transform(
    final String functionName,
    final TypeInformation<OUT> outTypeInfo,
    final TwoInputStreamOperator<IN1, IN2, OUT> operator) {
  // read the output type of the input Transforms to coax out errors about MissingTypeInfo
  inputStream1.getType();
  inputStream2.getType();
  TwoInputTransformation<IN1, IN2, OUT> transform = new TwoInputTransformation<>(
      inputStream1.getTransformation(),
      inputStream2.getTransformation(),
      functionName,
      operator,
      outTypeInfo,
      environment.getParallelism());
  if (inputStream1 instanceof KeyedStream) {
    KeyedStream<IN1, ?> keyedInput1 = (KeyedStream<IN1, ?>) inputStream1;
    TypeInformation<?> keyType1 = keyedInput1.getKeyType();
    transform.setStateKeySelectors(keyedInput1.getKeySelector(), null);
    transform.setStateKeyType(keyType1);
  }
  @SuppressWarnings({ "unchecked", "rawtypes" })
  SingleOutputStreamOperator<OUT> returnStream = new SingleOutputStreamOperator(environment, transform);
  getExecutionEnvironment().addOperator(transform);
  return returnStream;
}

keyedWorkItemStream.getExecutionEnvironment().addOperator(rawFlinkTransform);

keyedWorkItemStream.getExecutionEnvironment().addOperator(rawFlinkTransform);

keyedWorkItemStream.getExecutionEnvironment().addOperator(rawFlinkTransform);