KafkaConsumerImpl (Vertx Javadocs 4.0.3.GA API)

java.lang.Object
- io.vertx.kafka.client.consumer.impl.KafkaConsumerImpl<K,V>

All Implemented Interfaces:

ReadStream<KafkaConsumerRecord<K,V>>, StreamBase, KafkaConsumer<K,V>
```
public class KafkaConsumerImpl<K,V>
extends Object
implements KafkaConsumer<K,V>
```
Vert.x Kafka consumer implementation

Constructor Summary

Constructors
Constructor and Description

KafkaConsumerImpl(KafkaReadStream<K,V> stream)

Constructors
Constructor and Description
`KafkaConsumerImpl(KafkaReadStream<K,V> stream)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Future<Void>`	`assign(Set<TopicPartition> topicPartitions)` Manually assign a list of partition to this consumer.
`KafkaConsumer<K,V>`	`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
`Future<Void>`	`assign(TopicPartition topicPartition)` Manually assign a partition to this consumer.
`KafkaConsumer<K,V>`	`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
`Future<Set<TopicPartition>>`	`assignment()` Like `KafkaConsumer.assignment(Handler)` but returns a `Future` of the asynchronous result
`KafkaConsumer<K,V>`	`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
`KafkaReadStream<K,V>`	`asStream()`
`KafkaConsumer<K,V>`	`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
`Future<Map<TopicPartition,Long>>`	`beginningOffsets(Set<TopicPartition> topicPartitions)` Like `KafkaConsumer.beginningOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
`void`	`beginningOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the first offset for the given partitions.
`Future<Long>`	`beginningOffsets(TopicPartition topicPartition)` Like `KafkaConsumer.beginningOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
`void`	`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
`Future<Void>`	`close()` Close the consumer
`void`	`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
`Future<Void>`	`commit()` Commit current offsets for all the subscribed list of topics and partition.
`void`	`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
`Future<Map<TopicPartition,OffsetAndMetadata>>`	`commit(Map<TopicPartition,OffsetAndMetadata> offsets)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
`void`	`commit(Map<TopicPartition,OffsetAndMetadata> offsets, Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
`Future<OffsetAndMetadata>`	`committed(TopicPartition topicPartition)` Like `KafkaConsumer.committed(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
`void`	`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
`long`	`demand()` Returns the current demand.
`KafkaConsumer<K,V>`	`endHandler(Handler<Void> endHandler)` Set an end handler.
`Future<Map<TopicPartition,Long>>`	`endOffsets(Set<TopicPartition> topicPartitions)` Like `KafkaConsumer.endOffsets(Set, Handler)` but returns a `Future` of the asynchronous result
`void`	`endOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the last offset for the given partitions.
`Future<Long>`	`endOffsets(TopicPartition topicPartition)` Like `KafkaConsumer.endOffsets(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
`void`	`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
`KafkaConsumer<K,V>`	`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
`KafkaConsumer<K,V>`	`fetch(long amount)` Fetch the specified `amount` of elements.
`KafkaConsumer<K,V>`	`handler(Handler<KafkaConsumerRecord<K,V>> handler)` Set a data handler.
`Future<Map<String,List<PartitionInfo>>>`	`listTopics()` Like `KafkaConsumer.listTopics(Handler)` but returns a `Future` of the asynchronous result
`KafkaConsumer<K,V>`	`listTopics(Handler<AsyncResult<Map<String,List<PartitionInfo>>>> handler)` Get metadata about partitions for all topics that the user is authorized to view.
`Future<Map<TopicPartition,OffsetAndTimestamp>>`	`offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps)` Like `KafkaConsumer.offsetsForTimes(Map, Handler)` but returns a `Future` of the asynchronous result
`void`	`offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps, Handler<AsyncResult<Map<TopicPartition,OffsetAndTimestamp>>> handler)` Look up the offsets for the given partitions by timestamp.
`Future<OffsetAndTimestamp>`	`offsetsForTimes(TopicPartition topicPartition, Long timestamp)` Like `KafkaConsumer.offsetsForTimes(TopicPartition, Long, Handler)` but returns a `Future` of the asynchronous result
`void`	`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
`KafkaConsumer<K,V>`	`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
`Future<List<PartitionInfo>>`	`partitionsFor(String topic)` Like `KafkaConsumer.partitionsFor(String, Handler)` but returns a `Future` of the asynchronous result
`KafkaConsumer<K,V>`	`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
`KafkaConsumer<K,V>`	`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
`KafkaConsumer<K,V>`	`pause()` Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
`Future<Void>`	`pause(Set<TopicPartition> topicPartitions)` Suspend fetching from the requested partitions.
`KafkaConsumer<K,V>`	`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
`Future<Void>`	`pause(TopicPartition topicPartition)` Suspend fetching from the requested partition.
`KafkaConsumer<K,V>`	`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
`Future<Set<TopicPartition>>`	`paused()` Like `KafkaConsumer.paused(Handler)` but returns a `Future` of the asynchronous result
`void`	`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
`Future<KafkaConsumerRecords<K,V>>`	`poll(Duration timeout)` Like `KafkaConsumer.poll(Duration, Handler)` but returns a `Future` of the asynchronous result
`void`	`poll(Duration timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka.
`KafkaConsumer<K,V>`	`pollTimeout(Duration timeout)` Sets the poll timeout for the underlying native Kafka Consumer.
`Future<Long>`	`position(TopicPartition partition)` Like `KafkaConsumer.position(TopicPartition, Handler)` but returns a `Future` of the asynchronous result
`void`	`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
`KafkaConsumerImpl<K,V>`	`registerCloseHook()`
`KafkaConsumer<K,V>`	`resume()` Resume reading, and sets the buffer in `flowing` mode.
`Future<Void>`	`resume(Set<TopicPartition> topicPartitions)` Resume specified partitions which have been paused with pause.
`KafkaConsumer<K,V>`	`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
`Future<Void>`	`resume(TopicPartition topicPartition)` Resume specified partition which have been paused with pause.
`KafkaConsumer<K,V>`	`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
`Future<Void>`	`seek(TopicPartition topicPartition, long offset)` Overrides the fetch offsets that the consumer will use on the next poll.
`KafkaConsumer<K,V>`	`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
`Future<Void>`	`seekToBeginning(Set<TopicPartition> topicPartitions)` Seek to the first offset for each of the given partitions.
`KafkaConsumer<K,V>`	`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
`Future<Void>`	`seekToBeginning(TopicPartition topicPartition)` Seek to the first offset for each of the given partition.
`KafkaConsumer<K,V>`	`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
`Future<Void>`	`seekToEnd(Set<TopicPartition> topicPartitions)` Seek to the last offset for each of the given partitions.
`KafkaConsumer<K,V>`	`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
`Future<Void>`	`seekToEnd(TopicPartition topicPartition)` Seek to the last offset for each of the given partition.
`KafkaConsumer<K,V>`	`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
`Future<Void>`	`subscribe(Pattern pattern)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
`KafkaConsumer<K,V>`	`subscribe(Pattern pattern, Handler<AsyncResult<Void>> completionHandler)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
`Future<Void>`	`subscribe(Set<String> topics)` Subscribe to the given list of topics to get dynamically assigned partitions.
`KafkaConsumer<K,V>`	`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
`Future<Void>`	`subscribe(String topic)` Subscribe to the given topic to get dynamically assigned partitions.
`KafkaConsumer<K,V>`	`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
`Future<Set<String>>`	`subscription()` Like `KafkaConsumer.subscription(Handler)` but returns a `Future` of the asynchronous result
`KafkaConsumer<K,V>`	`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
`Future<Void>`	`unsubscribe()` Unsubscribe from topics currently subscribed with subscribe.
`KafkaConsumer<K,V>`	`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.
`org.apache.kafka.clients.consumer.Consumer<K,V>`	`unwrap()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.vertx.kafka.client.consumer.KafkaConsumer
create, create, create, create, create, create, create, create, create, create

Methods inherited from interface io.vertx.core.streams.ReadStream
pipe, pipeTo, pipeTo

- Constructor Detail
  - KafkaConsumerImpl
```
public KafkaConsumerImpl(KafkaReadStream<K,V> stream)
```
- Method Detail
  - registerCloseHook
```
public KafkaConsumerImpl<K,V> registerCloseHook()
```
  - exceptionHandler
```
public KafkaConsumer<K,V> exceptionHandler(Handler<Throwable> handler)
```
    Description copied from interface: ReadStream
    
    Set an exception handler on the read stream.
    
    Specified by:
    
    exceptionHandler in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    exceptionHandler in interface StreamBase
    
    Specified by:
    
    exceptionHandler in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - the exception handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - handler
```
public KafkaConsumer<K,V> handler(Handler<KafkaConsumerRecord<K,V>> handler)
```
    Description copied from interface: ReadStream
    
    Set a data handler. As data is read, the handler will be called with the data.
    
    Specified by:
    
    handler in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    handler in interface KafkaConsumer<K,V>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - pause
```
public KafkaConsumer<K,V> pause()
```
    Description copied from interface: ReadStream
    
    Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.
    While it's paused, no data will be sent to the data handler.
    
    Specified by:
    
    pause in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    pause in interface KafkaConsumer<K,V>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - resume
```
public KafkaConsumer<K,V> resume()
```
    Description copied from interface: ReadStream
    
    Resume reading, and sets the buffer in flowing mode.
    If the ReadStream has been paused, reading will recommence on it.
    
    Specified by:
    
    resume in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    resume in interface KafkaConsumer<K,V>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - fetch
```
public KafkaConsumer<K,V> fetch(long amount)
```
    Description copied from interface: ReadStream
    
    Fetch the specified amount of elements. If the ReadStream has been paused, reading will recommence with the specified amount of items, otherwise the specified amount will be added to the current stream demand.
    
    Specified by:
    
    fetch in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    fetch in interface KafkaConsumer<K,V>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - demand
```
public long demand()
```
    Description copied from interface: KafkaConsumer
    Returns the current demand.
    - If the stream is in fetch mode, will return the current number of elements still to be delivered or 0 if paused.
    Specified by:
    
    demand in interface KafkaConsumer<K,V>
    
    Returns:
    
    current demand
  - pause
```
public Future<Void> pause(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Suspend fetching from the requested partitions.
    
    Specified by:
    
    pause in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition from which suspend fetching
    
    Returns:
    
    a Future completed with the operation result
  - pause
```
public KafkaConsumer<K,V> pause(TopicPartition topicPartition,
                                Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Suspend fetching from the requested partition.
    Due to internal buffering of messages, the record handler will continue to observe messages from the given topicPartition until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will not see messages from the given topicPartition.
    
    Specified by:
    
    pause in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition from which suspend fetching
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - pause
```
public KafkaConsumer<K,V> pause(Set<TopicPartition> topicPartitions,
                                Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Suspend fetching from the requested partitions.
    Due to internal buffering of messages, the record handler will continue to observe messages from the given topicPartitions until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will not see messages from the given topicPartitions.
    
    Specified by:
    
    pause in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition from which suspend fetching
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - paused
```
public void paused(Handler<AsyncResult<Set<TopicPartition>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the set of partitions that were previously paused by a call to pause(Set).
    
    Specified by:
    
    paused in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on operation completed
  - paused
```
public Future<Set<TopicPartition>> paused()
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.paused(Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    paused in interface KafkaConsumer<K,V>
  - resume
```
public Future<Void> resume(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Resume specified partition which have been paused with pause.
    
    Specified by:
    
    resume in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition from which resume fetching
    
    Returns:
    
    a Future completed with the operation result
  - resume
```
public Future<Void> resume(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Resume specified partitions which have been paused with pause.
    
    Specified by:
    
    resume in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition from which resume fetching
    
    Returns:
    
    a Future completed with the operation result
  - resume
```
public KafkaConsumer<K,V> resume(TopicPartition topicPartition,
                                 Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Resume specified partition which have been paused with pause.
    
    Specified by:
    
    resume in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition from which resume fetching
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - resume
```
public KafkaConsumer<K,V> resume(Set<TopicPartition> topicPartitions,
                                 Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Resume specified partitions which have been paused with pause.
    
    Specified by:
    
    resume in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition from which resume fetching
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - endHandler
```
public KafkaConsumer<K,V> endHandler(Handler<Void> endHandler)
```
    Description copied from interface: ReadStream
    
    Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
    
    Specified by:
    
    endHandler in interface ReadStream<KafkaConsumerRecord<K,V>>
    
    Specified by:
    
    endHandler in interface KafkaConsumer<K,V>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - subscribe
```
public Future<Void> subscribe(String topic)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to the given topic to get dynamically assigned partitions.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topic - topic to subscribe to
    
    Returns:
    
    a Future completed with the operation result
  - subscribe
```
public Future<Void> subscribe(Set<String> topics)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to the given list of topics to get dynamically assigned partitions.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topics - topics to subscribe to
    
    Returns:
    
    a Future completed with the operation result
  - subscribe
```
public KafkaConsumer<K,V> subscribe(String topic,
                                    Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to the given topic to get dynamically assigned partitions.
    Due to internal buffering of messages, when changing the subscribed topic the old topic may remain in effect (as observed by the KafkaConsumer.handler(Handler) record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new topic.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topic - topic to subscribe to
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - subscribe
```
public KafkaConsumer<K,V> subscribe(Set<String> topics,
                                    Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to the given list of topics to get dynamically assigned partitions.
    Due to internal buffering of messages, when changing the subscribed topics the old set of topics may remain in effect (as observed by the KafkaConsumer.handler(Handler) record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new set of topics.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topics - topics to subscribe to
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - subscribe
```
public Future<Void> subscribe(Pattern pattern)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    pattern - Pattern to subscribe to
    
    Returns:
    
    a Future completed with the operation result
  - subscribe
```
public KafkaConsumer<K,V> subscribe(Pattern pattern,
                                    Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    Due to internal buffering of messages, when changing the subscribed topics the old set of topics may remain in effect (as observed by the KafkaConsumer.handler(Handler) record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new set of topics.
    
    Specified by:
    
    subscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    pattern - Pattern to subscribe to
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - assign
```
public Future<Void> assign(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Manually assign a partition to this consumer.
    
    Specified by:
    
    assign in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - partition which want assigned
    
    Returns:
    
    a Future completed with the operation result
  - assign
```
public Future<Void> assign(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Manually assign a list of partition to this consumer.
    
    Specified by:
    
    assign in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - partitions which want assigned
    
    Returns:
    
    a Future completed with the operation result
  - assign
```
public KafkaConsumer<K,V> assign(TopicPartition topicPartition,
                                 Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Manually assign a partition to this consumer.
    Due to internal buffering of messages, when reassigning the old partition may remain in effect (as observed by the KafkaConsumer.handler(Handler) record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new partition.
    
    Specified by:
    
    assign in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - partition which want assigned
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - assign
```
public KafkaConsumer<K,V> assign(Set<TopicPartition> topicPartitions,
                                 Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Manually assign a list of partition to this consumer.
    Due to internal buffering of messages, when reassigning the old set of partitions may remain in effect (as observed by the KafkaConsumer.handler(Handler) record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new set of partitions.
    
    Specified by:
    
    assign in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - partitions which want assigned
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - assignment
```
public KafkaConsumer<K,V> assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the set of partitions currently assigned to this consumer.
    
    Specified by:
    
    assignment in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - assignment
```
public Future<Set<TopicPartition>> assignment()
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.assignment(Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    assignment in interface KafkaConsumer<K,V>
  - listTopics
```
public KafkaConsumer<K,V> listTopics(Handler<AsyncResult<Map<String,List<PartitionInfo>>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get metadata about partitions for all topics that the user is authorized to view.
    
    Specified by:
    
    listTopics in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - listTopics
```
public Future<Map<String,List<PartitionInfo>>> listTopics()
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.listTopics(Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    listTopics in interface KafkaConsumer<K,V>
  - unsubscribe
```
public Future<Void> unsubscribe()
```
    Description copied from interface: KafkaConsumer
    
    Unsubscribe from topics currently subscribed with subscribe.
    
    Specified by:
    
    unsubscribe in interface KafkaConsumer<K,V>
    
    Returns:
    
    a Future completed with the operation result
  - unsubscribe
```
public KafkaConsumer<K,V> unsubscribe(Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Unsubscribe from topics currently subscribed with subscribe.
    
    Specified by:
    
    unsubscribe in interface KafkaConsumer<K,V>
    
    Parameters:
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - subscription
```
public KafkaConsumer<K,V> subscription(Handler<AsyncResult<Set<String>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the current subscription.
    
    Specified by:
    
    subscription in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - subscription
```
public Future<Set<String>> subscription()
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.subscription(Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    subscription in interface KafkaConsumer<K,V>
  - pause
```
public Future<Void> pause(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Suspend fetching from the requested partition.
    
    Specified by:
    
    pause in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition from which suspend fetching
    
    Returns:
    
    a Future completed with the operation result
  - partitionsRevokedHandler
```
public KafkaConsumer<K,V> partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Set the handler called when topic partitions are revoked to the consumer
    
    Specified by:
    
    partitionsRevokedHandler in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on revoked topic partitions
    
    Returns:
    
    current KafkaConsumer instance
  - partitionsAssignedHandler
```
public KafkaConsumer<K,V> partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Set the handler called when topic partitions are assigned to the consumer
    
    Specified by:
    
    partitionsAssignedHandler in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called on assigned topic partitions
    
    Returns:
    
    current KafkaConsumer instance
  - seek
```
public Future<Void> seek(TopicPartition topicPartition,
                         long offset)
```
    Description copied from interface: KafkaConsumer
    
    Overrides the fetch offsets that the consumer will use on the next poll.
    
    Specified by:
    
    seek in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    offset - offset to seek inside the topic partition
    
    Returns:
    
    a Future completed with the operation result
  - seek
```
public KafkaConsumer<K,V> seek(TopicPartition topicPartition,
                               long offset,
                               Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Overrides the fetch offsets that the consumer will use on the next poll.
    Due to internal buffering of messages, the record handler will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new offset.
    
    Specified by:
    
    seek in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    offset - offset to seek inside the topic partition
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - seekToBeginning
```
public Future<Void> seekToBeginning(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the first offset for each of the given partition.
    
    Specified by:
    
    seekToBeginning in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    Returns:
    
    a Future completed with the operation result
  - seekToBeginning
```
public Future<Void> seekToBeginning(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the first offset for each of the given partitions.
    
    Specified by:
    
    seekToBeginning in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition for which seek
    
    Returns:
    
    a Future completed with the operation result
  - seekToBeginning
```
public KafkaConsumer<K,V> seekToBeginning(TopicPartition topicPartition,
                                          Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the first offset for each of the given partition.
    Due to internal buffering of messages, the record handler will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new offset.
    
    Specified by:
    
    seekToBeginning in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - seekToBeginning
```
public KafkaConsumer<K,V> seekToBeginning(Set<TopicPartition> topicPartitions,
                                          Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the first offset for each of the given partitions.
    Due to internal buffering of messages, the record handler will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new offset.
    
    Specified by:
    
    seekToBeginning in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition for which seek
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - seekToEnd
```
public Future<Void> seekToEnd(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the last offset for each of the given partition.
    
    Specified by:
    
    seekToEnd in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    Returns:
    
    a Future completed with the operation result
  - seekToEnd
```
public Future<Void> seekToEnd(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the last offset for each of the given partitions.
    
    Specified by:
    
    seekToEnd in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition for which seek
    
    Returns:
    
    a Future completed with the operation result
  - seekToEnd
```
public KafkaConsumer<K,V> seekToEnd(TopicPartition topicPartition,
                                    Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the last offset for each of the given partition.
    Due to internal buffering of messages, the record handler will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new offset.
    
    Specified by:
    
    seekToEnd in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for which seek
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - seekToEnd
```
public KafkaConsumer<K,V> seekToEnd(Set<TopicPartition> topicPartitions,
                                    Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Seek to the last offset for each of the given partitions.
    Due to internal buffering of messages, the record handler will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the KafkaConsumer.batchHandler(Handler) will only see messages consistent with the new offset.
    
    Specified by:
    
    seekToEnd in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - topic partition for which seek
    
    completionHandler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - commit
```
public Future<Void> commit()
```
    Description copied from interface: KafkaConsumer
    
    Commit current offsets for all the subscribed list of topics and partition.
    
    Specified by:
    
    commit in interface KafkaConsumer<K,V>
  - commit
```
public void commit(Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Commit current offsets for all the subscribed list of topics and partition.
    
    Specified by:
    
    commit in interface KafkaConsumer<K,V>
    
    Parameters:
    
    completionHandler - handler called on operation completed
  - commit
```
public Future<Map<TopicPartition,OffsetAndMetadata>> commit(Map<TopicPartition,OffsetAndMetadata> offsets)
```
    Description copied from interface: KafkaConsumer
    
    Commit the specified offsets for the specified list of topics and partitions to Kafka.
    
    Specified by:
    
    commit in interface KafkaConsumer<K,V>
    
    Parameters:
    
    offsets - offsets list to commit
  - commit
```
public void commit(Map<TopicPartition,OffsetAndMetadata> offsets,
                   Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Commit the specified offsets for the specified list of topics and partitions to Kafka.
    
    Specified by:
    
    commit in interface KafkaConsumer<K,V>
    
    Parameters:
    
    offsets - offsets list to commit
    
    completionHandler - handler called on operation completed
  - committed
```
public void committed(TopicPartition topicPartition,
                      Handler<AsyncResult<OffsetAndMetadata>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the last committed offset for the given partition (whether the commit happened by this process or another).
    
    Specified by:
    
    committed in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - topic partition for getting last committed offset
    
    handler - handler called on operation completed
  - committed
```
public Future<OffsetAndMetadata> committed(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.committed(TopicPartition, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    committed in interface KafkaConsumer<K,V>
  - partitionsFor
```
public KafkaConsumer<K,V> partitionsFor(String topic,
                                        Handler<AsyncResult<List<PartitionInfo>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get metadata about the partitions for a given topic.
    
    Specified by:
    
    partitionsFor in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topic - topic partition for which getting partitions info
    
    handler - handler called on operation completed
    
    Returns:
    
    current KafkaConsumer instance
  - partitionsFor
```
public Future<List<PartitionInfo>> partitionsFor(String topic)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.partitionsFor(String, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    partitionsFor in interface KafkaConsumer<K,V>
  - close
```
public Future<Void> close()
```
    Description copied from interface: KafkaConsumer
    
    Close the consumer
    
    Specified by:
    
    close in interface KafkaConsumer<K,V>
  - close
```
public void close(Handler<AsyncResult<Void>> completionHandler)
```
    Description copied from interface: KafkaConsumer
    
    Close the consumer
    
    Specified by:
    
    close in interface KafkaConsumer<K,V>
    
    Parameters:
    
    completionHandler - handler called on operation completed
  - position
```
public void position(TopicPartition partition,
                     Handler<AsyncResult<Long>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the offset of the next record that will be fetched (if a record with that offset exists).
    
    Specified by:
    
    position in interface KafkaConsumer<K,V>
    
    Parameters:
    
    partition - The partition to get the position for
    
    handler - handler called on operation completed
  - position
```
public Future<Long> position(TopicPartition partition)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.position(TopicPartition, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    position in interface KafkaConsumer<K,V>
  - offsetsForTimes
```
public void offsetsForTimes(TopicPartition topicPartition,
                            Long timestamp,
                            Handler<AsyncResult<OffsetAndTimestamp>> handler)
```
    Description copied from interface: KafkaConsumer
    
    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
    
    Specified by:
    
    offsetsForTimes in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - TopicPartition to query.
    
    timestamp - Timestamp to be used in the query.
    
    handler - handler called on operation completed
  - offsetsForTimes
```
public Future<OffsetAndTimestamp> offsetsForTimes(TopicPartition topicPartition,
                                                  Long timestamp)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.offsetsForTimes(TopicPartition, Long, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    offsetsForTimes in interface KafkaConsumer<K,V>
  - offsetsForTimes
```
public void offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps,
                            Handler<AsyncResult<Map<TopicPartition,OffsetAndTimestamp>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Look up the offsets for the given partitions by timestamp. Note: the result might be empty in case for the given timestamp no offset can be found -- e.g., when the timestamp refers to the future
    
    Specified by:
    
    offsetsForTimes in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitionTimestamps - A map with pairs of (TopicPartition, Timestamp).
    
    handler - handler called on operation completed
  - offsetsForTimes
```
public Future<Map<TopicPartition,OffsetAndTimestamp>> offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.offsetsForTimes(Map, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    offsetsForTimes in interface KafkaConsumer<K,V>
  - beginningOffsets
```
public void beginningOffsets(Set<TopicPartition> topicPartitions,
                             Handler<AsyncResult<Map<TopicPartition,Long>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the first offset for the given partitions.
    
    Specified by:
    
    beginningOffsets in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - the partitions to get the earliest offsets.
    
    handler - handler called on operation completed. Returns the earliest available offsets for the given partitions
  - beginningOffsets
```
public Future<Map<TopicPartition,Long>> beginningOffsets(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.beginningOffsets(Set, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    beginningOffsets in interface KafkaConsumer<K,V>
  - beginningOffsets
```
public void beginningOffsets(TopicPartition topicPartition,
                             Handler<AsyncResult<Long>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the first offset for the given partitions.
    
    Specified by:
    
    beginningOffsets in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - the partition to get the earliest offset.
    
    handler - handler called on operation completed. Returns the earliest available offset for the given partition
  - beginningOffsets
```
public Future<Long> beginningOffsets(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.beginningOffsets(TopicPartition, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    beginningOffsets in interface KafkaConsumer<K,V>
  - endOffsets
```
public void endOffsets(Set<TopicPartition> topicPartitions,
                       Handler<AsyncResult<Map<TopicPartition,Long>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Get the last offset for the given partitions. The last offset of a partition is the offset of the upcoming message, i.e. the offset of the last available message + 1.
    
    Specified by:
    
    endOffsets in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartitions - the partitions to get the end offsets.
    
    handler - handler called on operation completed. The end offsets for the given partitions.
  - endOffsets
```
public Future<Map<TopicPartition,Long>> endOffsets(Set<TopicPartition> topicPartitions)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.endOffsets(Set, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    endOffsets in interface KafkaConsumer<K,V>
  - endOffsets
```
public void endOffsets(TopicPartition topicPartition,
                       Handler<AsyncResult<Long>> handler)
```
    Description copied from interface: KafkaConsumer
    
    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.
    
    Specified by:
    
    endOffsets in interface KafkaConsumer<K,V>
    
    Parameters:
    
    topicPartition - the partition to get the end offset.
    
    handler - handler called on operation completed. The end offset for the given partition.
  - endOffsets
```
public Future<Long> endOffsets(TopicPartition topicPartition)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.endOffsets(TopicPartition, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    endOffsets in interface KafkaConsumer<K,V>
  - asStream
```
public KafkaReadStream<K,V> asStream()
```
    Specified by:
    
    asStream in interface KafkaConsumer<K,V>
    
    Returns:
    
    underlying the KafkaReadStream instance
  - unwrap
```
public org.apache.kafka.clients.consumer.Consumer<K,V> unwrap()
```
    Specified by:
    
    unwrap in interface KafkaConsumer<K,V>
    
    Returns:
    
    the underlying consumer
  - batchHandler
```
public KafkaConsumer<K,V> batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Set the handler to be used when batches of messages are fetched from the Kafka server. Batch handlers need to take care not to block the event loop when dealing with large batches. It is better to process records individually using the record handler.
    
    Specified by:
    
    batchHandler in interface KafkaConsumer<K,V>
    
    Parameters:
    
    handler - handler called when batches of messages are fetched
    
    Returns:
    
    current KafkaConsumer instance
  - pollTimeout
```
public KafkaConsumer<K,V> pollTimeout(Duration timeout)
```
    Description copied from interface: KafkaConsumer
    
    Sets the poll timeout for the underlying native Kafka Consumer. Defaults to 1000ms. Setting timeout to a lower value results in a more 'responsive' client, because it will block for a shorter period if no data is available in the assigned partition and therefore allows subsequent actions to be executed with a shorter delay. At the same time, the client will poll more frequently and thus will potentially create a higher load on the Kafka Broker.
    
    Specified by:
    
    pollTimeout in interface KafkaConsumer<K,V>
    
    Parameters:
    
    timeout - The time, spent waiting in poll if data is not available in the buffer. If 0, returns immediately with any records that are available currently in the native Kafka consumer's buffer, else returns empty. Must not be negative.
  - poll
```
public void poll(Duration timeout,
                 Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)
```
    Description copied from interface: KafkaConsumer
    
    Executes a poll for getting messages from Kafka.
    
    Specified by:
    
    poll in interface KafkaConsumer<K,V>
    
    Parameters:
    
    timeout - The maximum time to block (must not be greater than Long.MAX_VALUE milliseconds)
    
    handler - handler called after the poll with batch of records (can be empty).
  - poll
```
public Future<KafkaConsumerRecords<K,V>> poll(Duration timeout)
```
    Description copied from interface: KafkaConsumer
    
    Like KafkaConsumer.poll(Duration, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    poll in interface KafkaConsumer<K,V>

Class KafkaConsumerImpl<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.kafka.client.consumer.KafkaConsumer

Methods inherited from interface io.vertx.core.streams.ReadStream

Constructor Detail

KafkaConsumerImpl

Method Detail

registerCloseHook

exceptionHandler

handler

pause

resume

fetch

demand

pause

pause

pause

paused

paused

resume

resume

resume

resume

endHandler

subscribe

subscribe

subscribe

subscribe

subscribe

subscribe

assign

assign

assign

assign

assignment

assignment

listTopics

listTopics

unsubscribe

unsubscribe

subscription

subscription

pause

partitionsRevokedHandler

partitionsAssignedHandler

seek

seek

seekToBeginning

seekToBeginning

seekToBeginning

seekToBeginning

seekToEnd

seekToEnd

seekToEnd

seekToEnd

commit

commit

commit

commit

committed

committed

partitionsFor

partitionsFor

close

close

position

position

offsetsForTimes

offsetsForTimes

offsetsForTimes

offsetsForTimes

beginningOffsets

beginningOffsets

beginningOffsets

beginningOffsets

endOffsets

endOffsets

endOffsets