Client.h

 
#ifndef PULSAR_CLIENT_HPP_
#define PULSAR_CLIENT_HPP_
 
#include <pulsar/ClientConfiguration.h>
#include <pulsar/ConsoleLoggerFactory.h>
#include <pulsar/Consumer.h>
#include <pulsar/FileLoggerFactory.h>
#include <pulsar/Message.h>
#include <pulsar/MessageBuilder.h>
#include <pulsar/Producer.h>
#include <pulsar/Reader.h>
#include <pulsar/Result.h>
#include <pulsar/Schema.h>
#include <pulsar/TableView.h>
#include <pulsar/defines.h>
 
#include <string>
 
namespace pulsar {
typedef std::function<void(Result, Producer)> CreateProducerCallback;
typedef std::function<void(Result, Consumer)> SubscribeCallback;
typedef std::function<void(Result, Reader)> ReaderCallback;
typedef std::function<void(Result, TableView)> TableViewCallback;
typedef std::function<void(Result, const std::vector<std::string>&)> GetPartitionsCallback;
typedef std::function<void(Result)> CloseCallback;
 
class ClientImpl;
class PulsarFriend;
class PulsarWrapper;
 
class PULSAR_PUBLIC Client {
   public:
    Client(const std::string& serviceUrl);
 
    Client(const std::string& serviceUrl, const ClientConfiguration& clientConfiguration);
 
    Result createProducer(const std::string& topic, Producer& producer);
 
    Result createProducer(const std::string& topic, const ProducerConfiguration& conf, Producer& producer);
 
    void createProducerAsync(const std::string& topic, CreateProducerCallback callback);
 
    void createProducerAsync(const std::string& topic, ProducerConfiguration conf,
                             CreateProducerCallback callback);
 
    Result subscribe(const std::string& topic, const std::string& subscriptionName, Consumer& consumer);
 
    Result subscribe(const std::string& topic, const std::string& subscriptionName,
                     const ConsumerConfiguration& conf, Consumer& consumer);
 
    void subscribeAsync(const std::string& topic, const std::string& subscriptionName,
                        SubscribeCallback callback);
 
    void subscribeAsync(const std::string& topic, const std::string& subscriptionName,
                        const ConsumerConfiguration& conf, SubscribeCallback callback);
 
    Result subscribe(const std::vector<std::string>& topics, const std::string& subscriptionName,
                     Consumer& consumer);
 
    Result subscribe(const std::vector<std::string>& topics, const std::string& subscriptionName,
                     const ConsumerConfiguration& conf, Consumer& consumer);
 
    void subscribeAsync(const std::vector<std::string>& topics, const std::string& subscriptionName,
                        SubscribeCallback callback);
 
    void subscribeAsync(const std::vector<std::string>& topics, const std::string& subscriptionName,
                        const ConsumerConfiguration& conf, SubscribeCallback callback);
 
    Result subscribeWithRegex(const std::string& regexPattern, const std::string& subscriptionName,
                              Consumer& consumer);
 
    Result subscribeWithRegex(const std::string& regexPattern, const std::string& subscriptionName,
                              const ConsumerConfiguration& conf, Consumer& consumer);
 
    void subscribeWithRegexAsync(const std::string& regexPattern, const std::string& subscriptionName,
                                 SubscribeCallback callback);
 
    void subscribeWithRegexAsync(const std::string& regexPattern, const std::string& subscriptionName,
                                 const ConsumerConfiguration& conf, SubscribeCallback callback);
 
    Result createReader(const std::string& topic, const MessageId& startMessageId,
                        const ReaderConfiguration& conf, Reader& reader);
 
    void createReaderAsync(const std::string& topic, const MessageId& startMessageId,
                           const ReaderConfiguration& conf, ReaderCallback callback);
 
    Result createTableView(const std::string& topic, const TableViewConfiguration& conf,
                           TableView& tableView);
 
    void createTableViewAsync(const std::string& topic, const TableViewConfiguration& conf,
                              TableViewCallback callBack);
 
    Result getPartitionsForTopic(const std::string& topic, std::vector<std::string>& partitions);
 
    void getPartitionsForTopicAsync(const std::string& topic, GetPartitionsCallback callback);
 
    Result close();
 
    void closeAsync(CloseCallback callback);
 
    void shutdown();
 
    uint64_t getNumberOfProducers();
 
    uint64_t getNumberOfConsumers();
 
    void getSchemaInfoAsync(const std::string& topic, int64_t version,
                            std::function<void(Result, const SchemaInfo&)> callback);
 
   private:
    Client(const std::string& serviceUrl, const ClientConfiguration& clientConfiguration,
           bool poolConnections);
    Client(const std::shared_ptr<ClientImpl>);
 
    friend class PulsarFriend;
    friend class PulsarWrapper;
    std::shared_ptr<ClientImpl> impl_;
};
}  // namespace pulsar
 
#endif /* PULSAR_CLIENT_HPP_ */