KafkaStreamingSourceOptions.h

 
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Glue
{
namespace Model
{
 
  class KafkaStreamingSourceOptions
  {
  public:
    AWS_GLUE_API KafkaStreamingSourceOptions() = default;
    AWS_GLUE_API KafkaStreamingSourceOptions(Aws::Utils::Json::JsonView jsonValue);
    AWS_GLUE_API KafkaStreamingSourceOptions& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetBootstrapServers() const { return m_bootstrapServers; }
    inline bool BootstrapServersHasBeenSet() const { return m_bootstrapServersHasBeenSet; }
    template<typename BootstrapServersT = Aws::String>
    void SetBootstrapServers(BootstrapServersT&& value) { m_bootstrapServersHasBeenSet = true; m_bootstrapServers = std::forward<BootstrapServersT>(value); }
    template<typename BootstrapServersT = Aws::String>
    KafkaStreamingSourceOptions& WithBootstrapServers(BootstrapServersT&& value) { SetBootstrapServers(std::forward<BootstrapServersT>(value)); return *this;}
 
 
    inline const Aws::String& GetSecurityProtocol() const { return m_securityProtocol; }
    inline bool SecurityProtocolHasBeenSet() const { return m_securityProtocolHasBeenSet; }
    template<typename SecurityProtocolT = Aws::String>
    void SetSecurityProtocol(SecurityProtocolT&& value) { m_securityProtocolHasBeenSet = true; m_securityProtocol = std::forward<SecurityProtocolT>(value); }
    template<typename SecurityProtocolT = Aws::String>
    KafkaStreamingSourceOptions& WithSecurityProtocol(SecurityProtocolT&& value) { SetSecurityProtocol(std::forward<SecurityProtocolT>(value)); return *this;}
 
 
    inline const Aws::String& GetConnectionName() const { return m_connectionName; }
    inline bool ConnectionNameHasBeenSet() const { return m_connectionNameHasBeenSet; }
    template<typename ConnectionNameT = Aws::String>
    void SetConnectionName(ConnectionNameT&& value) { m_connectionNameHasBeenSet = true; m_connectionName = std::forward<ConnectionNameT>(value); }
    template<typename ConnectionNameT = Aws::String>
    KafkaStreamingSourceOptions& WithConnectionName(ConnectionNameT&& value) { SetConnectionName(std::forward<ConnectionNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetTopicName() const { return m_topicName; }
    inline bool TopicNameHasBeenSet() const { return m_topicNameHasBeenSet; }
    template<typename TopicNameT = Aws::String>
    void SetTopicName(TopicNameT&& value) { m_topicNameHasBeenSet = true; m_topicName = std::forward<TopicNameT>(value); }
    template<typename TopicNameT = Aws::String>
    KafkaStreamingSourceOptions& WithTopicName(TopicNameT&& value) { SetTopicName(std::forward<TopicNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetAssign() const { return m_assign; }
    inline bool AssignHasBeenSet() const { return m_assignHasBeenSet; }
    template<typename AssignT = Aws::String>
    void SetAssign(AssignT&& value) { m_assignHasBeenSet = true; m_assign = std::forward<AssignT>(value); }
    template<typename AssignT = Aws::String>
    KafkaStreamingSourceOptions& WithAssign(AssignT&& value) { SetAssign(std::forward<AssignT>(value)); return *this;}
 
 
    inline const Aws::String& GetSubscribePattern() const { return m_subscribePattern; }
    inline bool SubscribePatternHasBeenSet() const { return m_subscribePatternHasBeenSet; }
    template<typename SubscribePatternT = Aws::String>
    void SetSubscribePattern(SubscribePatternT&& value) { m_subscribePatternHasBeenSet = true; m_subscribePattern = std::forward<SubscribePatternT>(value); }
    template<typename SubscribePatternT = Aws::String>
    KafkaStreamingSourceOptions& WithSubscribePattern(SubscribePatternT&& value) { SetSubscribePattern(std::forward<SubscribePatternT>(value)); return *this;}
 
 
    inline const Aws::String& GetClassification() const { return m_classification; }
    inline bool ClassificationHasBeenSet() const { return m_classificationHasBeenSet; }
    template<typename ClassificationT = Aws::String>
    void SetClassification(ClassificationT&& value) { m_classificationHasBeenSet = true; m_classification = std::forward<ClassificationT>(value); }
    template<typename ClassificationT = Aws::String>
    KafkaStreamingSourceOptions& WithClassification(ClassificationT&& value) { SetClassification(std::forward<ClassificationT>(value)); return *this;}
 
 
    inline const Aws::String& GetDelimiter() const { return m_delimiter; }
    inline bool DelimiterHasBeenSet() const { return m_delimiterHasBeenSet; }
    template<typename DelimiterT = Aws::String>
    void SetDelimiter(DelimiterT&& value) { m_delimiterHasBeenSet = true; m_delimiter = std::forward<DelimiterT>(value); }
    template<typename DelimiterT = Aws::String>
    KafkaStreamingSourceOptions& WithDelimiter(DelimiterT&& value) { SetDelimiter(std::forward<DelimiterT>(value)); return *this;}
 
 
    inline const Aws::String& GetStartingOffsets() const { return m_startingOffsets; }
    inline bool StartingOffsetsHasBeenSet() const { return m_startingOffsetsHasBeenSet; }
    template<typename StartingOffsetsT = Aws::String>
    void SetStartingOffsets(StartingOffsetsT&& value) { m_startingOffsetsHasBeenSet = true; m_startingOffsets = std::forward<StartingOffsetsT>(value); }
    template<typename StartingOffsetsT = Aws::String>
    KafkaStreamingSourceOptions& WithStartingOffsets(StartingOffsetsT&& value) { SetStartingOffsets(std::forward<StartingOffsetsT>(value)); return *this;}
 
 
    inline const Aws::String& GetEndingOffsets() const { return m_endingOffsets; }
    inline bool EndingOffsetsHasBeenSet() const { return m_endingOffsetsHasBeenSet; }
    template<typename EndingOffsetsT = Aws::String>
    void SetEndingOffsets(EndingOffsetsT&& value) { m_endingOffsetsHasBeenSet = true; m_endingOffsets = std::forward<EndingOffsetsT>(value); }
    template<typename EndingOffsetsT = Aws::String>
    KafkaStreamingSourceOptions& WithEndingOffsets(EndingOffsetsT&& value) { SetEndingOffsets(std::forward<EndingOffsetsT>(value)); return *this;}
 
 
    inline long long GetPollTimeoutMs() const { return m_pollTimeoutMs; }
    inline bool PollTimeoutMsHasBeenSet() const { return m_pollTimeoutMsHasBeenSet; }
    inline void SetPollTimeoutMs(long long value) { m_pollTimeoutMsHasBeenSet = true; m_pollTimeoutMs = value; }
    inline KafkaStreamingSourceOptions& WithPollTimeoutMs(long long value) { SetPollTimeoutMs(value); return *this;}
 
 
    inline int GetNumRetries() const { return m_numRetries; }
    inline bool NumRetriesHasBeenSet() const { return m_numRetriesHasBeenSet; }
    inline void SetNumRetries(int value) { m_numRetriesHasBeenSet = true; m_numRetries = value; }
    inline KafkaStreamingSourceOptions& WithNumRetries(int value) { SetNumRetries(value); return *this;}
 
 
    inline long long GetRetryIntervalMs() const { return m_retryIntervalMs; }
    inline bool RetryIntervalMsHasBeenSet() const { return m_retryIntervalMsHasBeenSet; }
    inline void SetRetryIntervalMs(long long value) { m_retryIntervalMsHasBeenSet = true; m_retryIntervalMs = value; }
    inline KafkaStreamingSourceOptions& WithRetryIntervalMs(long long value) { SetRetryIntervalMs(value); return *this;}
 
 
    inline long long GetMaxOffsetsPerTrigger() const { return m_maxOffsetsPerTrigger; }
    inline bool MaxOffsetsPerTriggerHasBeenSet() const { return m_maxOffsetsPerTriggerHasBeenSet; }
    inline void SetMaxOffsetsPerTrigger(long long value) { m_maxOffsetsPerTriggerHasBeenSet = true; m_maxOffsetsPerTrigger = value; }
    inline KafkaStreamingSourceOptions& WithMaxOffsetsPerTrigger(long long value) { SetMaxOffsetsPerTrigger(value); return *this;}
 
 
    inline int GetMinPartitions() const { return m_minPartitions; }
    inline bool MinPartitionsHasBeenSet() const { return m_minPartitionsHasBeenSet; }
    inline void SetMinPartitions(int value) { m_minPartitionsHasBeenSet = true; m_minPartitions = value; }
    inline KafkaStreamingSourceOptions& WithMinPartitions(int value) { SetMinPartitions(value); return *this;}
 
 
    inline bool GetIncludeHeaders() const { return m_includeHeaders; }
    inline bool IncludeHeadersHasBeenSet() const { return m_includeHeadersHasBeenSet; }
    inline void SetIncludeHeaders(bool value) { m_includeHeadersHasBeenSet = true; m_includeHeaders = value; }
    inline KafkaStreamingSourceOptions& WithIncludeHeaders(bool value) { SetIncludeHeaders(value); return *this;}
 
 
    inline const Aws::String& GetAddRecordTimestamp() const { return m_addRecordTimestamp; }
    inline bool AddRecordTimestampHasBeenSet() const { return m_addRecordTimestampHasBeenSet; }
    template<typename AddRecordTimestampT = Aws::String>
    void SetAddRecordTimestamp(AddRecordTimestampT&& value) { m_addRecordTimestampHasBeenSet = true; m_addRecordTimestamp = std::forward<AddRecordTimestampT>(value); }
    template<typename AddRecordTimestampT = Aws::String>
    KafkaStreamingSourceOptions& WithAddRecordTimestamp(AddRecordTimestampT&& value) { SetAddRecordTimestamp(std::forward<AddRecordTimestampT>(value)); return *this;}
 
 
    inline const Aws::String& GetEmitConsumerLagMetrics() const { return m_emitConsumerLagMetrics; }
    inline bool EmitConsumerLagMetricsHasBeenSet() const { return m_emitConsumerLagMetricsHasBeenSet; }
    template<typename EmitConsumerLagMetricsT = Aws::String>
    void SetEmitConsumerLagMetrics(EmitConsumerLagMetricsT&& value) { m_emitConsumerLagMetricsHasBeenSet = true; m_emitConsumerLagMetrics = std::forward<EmitConsumerLagMetricsT>(value); }
    template<typename EmitConsumerLagMetricsT = Aws::String>
    KafkaStreamingSourceOptions& WithEmitConsumerLagMetrics(EmitConsumerLagMetricsT&& value) { SetEmitConsumerLagMetrics(std::forward<EmitConsumerLagMetricsT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetStartingTimestamp() const { return m_startingTimestamp; }
    inline bool StartingTimestampHasBeenSet() const { return m_startingTimestampHasBeenSet; }
    template<typename StartingTimestampT = Aws::Utils::DateTime>
    void SetStartingTimestamp(StartingTimestampT&& value) { m_startingTimestampHasBeenSet = true; m_startingTimestamp = std::forward<StartingTimestampT>(value); }
    template<typename StartingTimestampT = Aws::Utils::DateTime>
    KafkaStreamingSourceOptions& WithStartingTimestamp(StartingTimestampT&& value) { SetStartingTimestamp(std::forward<StartingTimestampT>(value)); return *this;}
  private:
 
    Aws::String m_bootstrapServers;
    bool m_bootstrapServersHasBeenSet = false;
 
    Aws::String m_securityProtocol;
    bool m_securityProtocolHasBeenSet = false;
 
    Aws::String m_connectionName;
    bool m_connectionNameHasBeenSet = false;
 
    Aws::String m_topicName;
    bool m_topicNameHasBeenSet = false;
 
    Aws::String m_assign;
    bool m_assignHasBeenSet = false;
 
    Aws::String m_subscribePattern;
    bool m_subscribePatternHasBeenSet = false;
 
    Aws::String m_classification;
    bool m_classificationHasBeenSet = false;
 
    Aws::String m_delimiter;
    bool m_delimiterHasBeenSet = false;
 
    Aws::String m_startingOffsets;
    bool m_startingOffsetsHasBeenSet = false;
 
    Aws::String m_endingOffsets;
    bool m_endingOffsetsHasBeenSet = false;
 
    long long m_pollTimeoutMs{0};
    bool m_pollTimeoutMsHasBeenSet = false;
 
    int m_numRetries{0};
    bool m_numRetriesHasBeenSet = false;
 
    long long m_retryIntervalMs{0};
    bool m_retryIntervalMsHasBeenSet = false;
 
    long long m_maxOffsetsPerTrigger{0};
    bool m_maxOffsetsPerTriggerHasBeenSet = false;
 
    int m_minPartitions{0};
    bool m_minPartitionsHasBeenSet = false;
 
    bool m_includeHeaders{false};
    bool m_includeHeadersHasBeenSet = false;
 
    Aws::String m_addRecordTimestamp;
    bool m_addRecordTimestampHasBeenSet = false;
 
    Aws::String m_emitConsumerLagMetrics;
    bool m_emitConsumerLagMetricsHasBeenSet = false;
 
    Aws::Utils::DateTime m_startingTimestamp{};
    bool m_startingTimestampHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Glue
} // namespace Aws