/** * Resume specified partition which have been paused with pause. * @param topicPartition topic partition from which resume fetching * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> resume(TopicPartition topicPartition) { delegate.resume(topicPartition); return this; }
public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> handler(Handler<io.vertx.rxjava.kafka.client.consumer.KafkaConsumerRecord<K, V>> handler) { delegate.handler(new Handler<io.vertx.kafka.client.consumer.KafkaConsumerRecord<K,V>>() { public void handle(io.vertx.kafka.client.consumer.KafkaConsumerRecord<K,V> event) { handler.handle(io.vertx.rxjava.kafka.client.consumer.KafkaConsumerRecord.newInstance(event, __typeArg_0, __typeArg_1)); } }); return this; }
/** * Suspend fetching from the requested partition. * @param topicPartition topic partition from which suspend fetching * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> pause(TopicPartition topicPartition) { delegate.pause(topicPartition); return this; }
/** * Close the consumer * @param completionHandler handler called on operation completed */ public void close(Handler<AsyncResult<Void>> completionHandler) { delegate.close(completionHandler); }
/** * Seek to the first offset for each of the given partitions. * @param topicPartitions topic partition for which seek * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> seekToBeginning(Set<TopicPartition> topicPartitions) { delegate.seekToBeginning(topicPartitions); return this; }
/** * Get metadata about the partitions for a given topic. * @param topic topic partition for which getting partitions info * @param handler handler called on operation completed * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler) { delegate.partitionsFor(topic, handler); return this; }
/** * Subscribe to the given list of topics to get dynamically assigned partitions. * @param topics topics to subscribe to * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> subscribe(Set<String> topics) { delegate.subscribe(topics); return this; }
/** * Get the last committed offset for the given partition (whether the commit happened by this process or another). * @param topicPartition topic partition for getting last committed offset * @param handler handler called on operation completed */ public void committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler) { delegate.committed(topicPartition, handler); }
/** * Look up the offset for the given partition by timestamp. Note: the result might be null in case * for the given timestamp no offset can be found -- e.g., when the timestamp refers to the future * @param topicPartition TopicPartition to query. * @param timestamp Timestamp to be used in the query. * @param handler handler called on operation completed */ public void offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler) { delegate.offsetsForTimes(topicPartition, timestamp, handler); }
@Override <K, V> KafkaReadStream<K, V> createConsumer(Vertx vertx, Properties config) { return KafkaReadStream.create(vertx, config); } }
/** * Seek to the last offset for each of the given partitions. * @param topicPartitions topic partition for which seek * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> seekToEnd(Set<TopicPartition> topicPartitions) { delegate.seekToEnd(topicPartitions); return this; }
/** * Get the set of partitions currently assigned to this consumer. * @param handler handler called on operation completed * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> assignment(Handler<AsyncResult<Set<TopicPartition>>> handler) { delegate.assignment(handler); return this; }
/** * Get the last offset for the given partition. The last offset of a partition is the offset * of the upcoming message, i.e. the offset of the last available message + 1. * @param topicPartition the partition to get the end offset. * @param handler handler called on operation completed. The end offset for the given partition. */ public void endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler) { delegate.endOffsets(topicPartition, handler); }
/** * @return the timestamp type of this record */ public TimestampType timestampType() { TimestampType ret = delegate.timestampType(); return ret; }
/** * Unsubscribe from topics currently subscribed with subscribe. * @param completionHandler handler called on operation completed * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> unsubscribe(Handler<AsyncResult<Void>> completionHandler) { delegate.unsubscribe(completionHandler); return this; }
/** * Fetch the specified <code>amount</code> of elements. If the <code>ReadStream</code> has been paused, reading will * recommence with the specified <code>amount</code> of items, otherwise the specified <code>amount</code> will * be added to the current stream demand. * @param amount * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.kafka.client.consumer.KafkaConsumerRecord<K, V>> fetch(long amount) { delegate.fetch(amount); return this; }
/** * Resume specified partitions which have been paused with pause. * @param topicPartitions topic partition from which resume fetching * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> resume(Set<TopicPartition> topicPartitions) { delegate.resume(topicPartitions); return this; }
/** * Suspend fetching from the requested partitions. * @param topicPartitions topic partition from which suspend fetching * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> pause(Set<TopicPartition> topicPartitions) { delegate.pause(topicPartitions); return this; }
/** * Seek to the last offset for each of the given partition. * @param topicPartition topic partition for which seek * @return current KafkaConsumer instance */ public io.vertx.rxjava.kafka.client.consumer.KafkaConsumer<K, V> seekToEnd(TopicPartition topicPartition) { delegate.seekToEnd(topicPartition); return this; }