consumer.h

 
#pragma once
 
#include <pulsar/defines.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <pulsar/c/message.h>
#include <pulsar/c/messages.h>
#include <pulsar/c/result.h>
#include <stdint.h>
 
typedef struct _pulsar_consumer pulsar_consumer_t;
 
typedef void (*pulsar_result_callback)(pulsar_result, void *);
 
typedef void (*pulsar_receive_callback)(pulsar_result result, pulsar_message_t *msg, void *ctx);
 
typedef void (*pulsar_batch_receive_callback)(pulsar_result result, pulsar_messages_t *msgs, void *ctx);
 
PULSAR_PUBLIC const char *pulsar_consumer_get_topic(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC const char *pulsar_consumer_get_subscription_name(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_unsubscribe(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC void pulsar_consumer_unsubscribe_async(pulsar_consumer_t *consumer,
                                                     pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_receive(pulsar_consumer_t *consumer, pulsar_message_t **msg);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_receive_with_timeout(pulsar_consumer_t *consumer,
                                                                 pulsar_message_t **msg, int timeoutMs);
 
PULSAR_PUBLIC void pulsar_consumer_receive_async(pulsar_consumer_t *consumer,
                                                 pulsar_receive_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_batch_receive(pulsar_consumer_t *consumer,
                                                          pulsar_messages_t **msgs);
 
PULSAR_PUBLIC void pulsar_consumer_batch_receive_async(pulsar_consumer_t *consumer,
                                                       pulsar_batch_receive_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_acknowledge(pulsar_consumer_t *consumer,
                                                        pulsar_message_t *message);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_acknowledge_id(pulsar_consumer_t *consumer,
                                                           pulsar_message_id_t *messageId);
 
PULSAR_PUBLIC void pulsar_consumer_acknowledge_async(pulsar_consumer_t *consumer, pulsar_message_t *message,
                                                     pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC void pulsar_consumer_acknowledge_async_id(pulsar_consumer_t *consumer,
                                                        pulsar_message_id_t *messageId,
                                                        pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_acknowledge_cumulative(pulsar_consumer_t *consumer,
                                                                   pulsar_message_t *message);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_acknowledge_cumulative_id(pulsar_consumer_t *consumer,
                                                                      pulsar_message_id_t *messageId);
 
PULSAR_PUBLIC void pulsar_consumer_acknowledge_cumulative_async(pulsar_consumer_t *consumer,
                                                                pulsar_message_t *message,
                                                                pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC void pulsar_consumer_acknowledge_cumulative_async_id(pulsar_consumer_t *consumer,
                                                                   pulsar_message_id_t *messageId,
                                                                   pulsar_result_callback callback,
                                                                   void *ctx);
 
PULSAR_PUBLIC void pulsar_consumer_negative_acknowledge(pulsar_consumer_t *consumer,
                                                        pulsar_message_t *message);
 
PULSAR_PUBLIC void pulsar_consumer_negative_acknowledge_id(pulsar_consumer_t *consumer,
                                                           pulsar_message_id_t *messageId);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_close(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC void pulsar_consumer_close_async(pulsar_consumer_t *consumer, pulsar_result_callback callback,
                                               void *ctx);
 
PULSAR_PUBLIC void pulsar_consumer_free(pulsar_consumer_t *consumer);
 
/*
 * Pause receiving messages via the messageListener, till resumeMessageListener() is called.
 */
PULSAR_PUBLIC pulsar_result pulsar_consumer_pause_message_listener(pulsar_consumer_t *consumer);
 
/*
 * Resume receiving the messages via the messageListener.
 * Asynchronously receive all the messages enqueued from time pauseMessageListener() was called.
 */
PULSAR_PUBLIC pulsar_result resume_message_listener(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC void pulsar_consumer_redeliver_unacknowledged_messages(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC void pulsar_consumer_seek_async(pulsar_consumer_t *consumer, pulsar_message_id_t *messageId,
                                              pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_seek(pulsar_consumer_t *consumer, pulsar_message_id_t *messageId);
 
PULSAR_PUBLIC void pulsar_consumer_seek_by_timestamp_async(pulsar_consumer_t *consumer, uint64_t timestamp,
                                                           pulsar_result_callback callback, void *ctx);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_seek_by_timestamp(pulsar_consumer_t *consumer,
                                                              uint64_t timestamp);
 
PULSAR_PUBLIC int pulsar_consumer_is_connected(pulsar_consumer_t *consumer);
 
PULSAR_PUBLIC pulsar_result pulsar_consumer_get_last_message_id(pulsar_consumer_t *consumer,
                                                                pulsar_message_id_t *messageId);
 
#ifdef __cplusplus
}
#endif