ProducerConfiguration.h

 
#ifndef PULSAR_PRODUCERCONFIGURATION_H_
#define PULSAR_PRODUCERCONFIGURATION_H_
#include <pulsar/CompressionType.h>
#include <pulsar/CryptoKeyReader.h>
#include <pulsar/Message.h>
#include <pulsar/MessageRoutingPolicy.h>
#include <pulsar/ProducerCryptoFailureAction.h>
#include <pulsar/ProducerInterceptor.h>
#include <pulsar/Result.h>
#include <pulsar/Schema.h>
#include <pulsar/defines.h>
 
#include <cstdint>
#include <functional>
#include <set>
 
namespace pulsar {
 
typedef std::function<void(Result, const MessageId& messageId)> SendCallback;
typedef std::function<void(Result)> CloseCallback;
 
struct ProducerConfigurationImpl;
class PulsarWrapper;
 
class PULSAR_PUBLIC ProducerConfiguration {
   public:
    enum PartitionsRoutingMode : uint8_t
    {
        UseSinglePartition,
        RoundRobinDistribution,
        CustomPartition
    };
    enum HashingScheme : uint8_t
    {
        Murmur3_32Hash,
        BoostHash,
        JavaStringHash
    };
    enum BatchingType : uint8_t
    {
        DefaultBatching,
 
        KeyBasedBatching
    };
    enum ProducerAccessMode : uint8_t
    {
        Shared = 0,
 
        Exclusive = 1,
 
        WaitForExclusive = 2,
 
        ExclusiveWithFencing = 3
    };
 
    ProducerConfiguration();
    ~ProducerConfiguration();
    ProducerConfiguration(const ProducerConfiguration&);
    ProducerConfiguration& operator=(const ProducerConfiguration&);
 
    ProducerConfiguration& setProducerName(const std::string& producerName);
 
    const std::string& getProducerName() const;
 
    ProducerConfiguration& setSchema(const SchemaInfo& schemaInfo);
 
    const SchemaInfo& getSchema() const;
 
    ProducerConfiguration& setSendTimeout(int sendTimeoutMs);
 
    int getSendTimeout() const;
 
    ProducerConfiguration& setInitialSequenceId(int64_t initialSequenceId);
 
    int64_t getInitialSequenceId() const;
 
    ProducerConfiguration& setCompressionType(CompressionType compressionType);
 
    CompressionType getCompressionType() const;
 
    ProducerConfiguration& setMaxPendingMessages(int maxPendingMessages);
 
    int getMaxPendingMessages() const;
 
    ProducerConfiguration& setMaxPendingMessagesAcrossPartitions(int maxPendingMessagesAcrossPartitions);
 
    int getMaxPendingMessagesAcrossPartitions() const;
 
    ProducerConfiguration& setPartitionsRoutingMode(const PartitionsRoutingMode& mode);
 
    PartitionsRoutingMode getPartitionsRoutingMode() const;
 
    ProducerConfiguration& setMessageRouter(const MessageRoutingPolicyPtr& router);
 
    const MessageRoutingPolicyPtr& getMessageRouterPtr() const;
 
    ProducerConfiguration& setHashingScheme(const HashingScheme& scheme);
 
    HashingScheme getHashingScheme() const;
 
    ProducerConfiguration& setLazyStartPartitionedProducers(bool);
 
    bool getLazyStartPartitionedProducers() const;
 
    ProducerConfiguration& setBlockIfQueueFull(bool);
 
    bool getBlockIfQueueFull() const;
 
    // Zero queue size feature will not be supported on consumer end if batching is enabled
 
    ProducerConfiguration& setBatchingEnabled(const bool& batchingEnabled);
 
    const bool& getBatchingEnabled() const;
 
    ProducerConfiguration& setBatchingMaxMessages(const unsigned int& batchingMaxMessages);
 
    const unsigned int& getBatchingMaxMessages() const;
 
    ProducerConfiguration& setBatchingMaxAllowedSizeInBytes(
        const unsigned long& batchingMaxAllowedSizeInBytes);
 
    const unsigned long& getBatchingMaxAllowedSizeInBytes() const;
 
    ProducerConfiguration& setBatchingMaxPublishDelayMs(const unsigned long& batchingMaxPublishDelayMs);
 
    const unsigned long& getBatchingMaxPublishDelayMs() const;
 
    ProducerConfiguration& setBatchingType(BatchingType batchingType);
 
    BatchingType getBatchingType() const;
 
    const CryptoKeyReaderPtr getCryptoKeyReader() const;
 
    ProducerConfiguration& setCryptoKeyReader(CryptoKeyReaderPtr cryptoKeyReader);
 
    ProducerCryptoFailureAction getCryptoFailureAction() const;
 
    ProducerConfiguration& setCryptoFailureAction(ProducerCryptoFailureAction action);
 
    const std::set<std::string>& getEncryptionKeys() const;
 
    bool isEncryptionEnabled() const;
 
    ProducerConfiguration& addEncryptionKey(const std::string& key);
 
    bool hasProperty(const std::string& name) const;
 
    const std::string& getProperty(const std::string& name) const;
 
    std::map<std::string, std::string>& getProperties() const;
 
    ProducerConfiguration& setProperty(const std::string& name, const std::string& value);
 
    ProducerConfiguration& setProperties(const std::map<std::string, std::string>& properties);
 
    ProducerConfiguration& setChunkingEnabled(bool chunkingEnabled);
 
    bool isChunkingEnabled() const;
 
    ProducerConfiguration& setAccessMode(const ProducerAccessMode& accessMode);
 
    ProducerAccessMode getAccessMode() const;
 
    ProducerConfiguration& intercept(const std::vector<ProducerInterceptorPtr>& interceptors);
 
    const std::vector<ProducerInterceptorPtr>& getInterceptors() const;
 
   private:
    std::shared_ptr<ProducerConfigurationImpl> impl_;
 
    friend class PulsarWrapper;
    friend class ConsumerImpl;
    friend class ProducerImpl;
};
}  // namespace pulsar
#endif /* PULSAR_PRODUCERCONFIGURATION_H_ */