KafkaStreamingSourceOptions.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/Glue_EXPORTS.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;
 
  Aws::String m_securityProtocol;
 
  Aws::String m_connectionName;
 
  Aws::String m_topicName;
 
  Aws::String m_assign;
 
  Aws::String m_subscribePattern;
 
  Aws::String m_classification;
 
  Aws::String m_delimiter;
 
  Aws::String m_startingOffsets;
 
  Aws::String m_endingOffsets;
 
  long long m_pollTimeoutMs{0};
 
  int m_numRetries{0};
 
  long long m_retryIntervalMs{0};
 
  long long m_maxOffsetsPerTrigger{0};
 
  int m_minPartitions{0};
 
  bool m_includeHeaders{false};
 
  Aws::String m_addRecordTimestamp;
 
  Aws::String m_emitConsumerLagMetrics;
 
  Aws::Utils::DateTime m_startingTimestamp{};
  bool m_bootstrapServersHasBeenSet = false;
  bool m_securityProtocolHasBeenSet = false;
  bool m_connectionNameHasBeenSet = false;
  bool m_topicNameHasBeenSet = false;
  bool m_assignHasBeenSet = false;
  bool m_subscribePatternHasBeenSet = false;
  bool m_classificationHasBeenSet = false;
  bool m_delimiterHasBeenSet = false;
  bool m_startingOffsetsHasBeenSet = false;
  bool m_endingOffsetsHasBeenSet = false;
  bool m_pollTimeoutMsHasBeenSet = false;
  bool m_numRetriesHasBeenSet = false;
  bool m_retryIntervalMsHasBeenSet = false;
  bool m_maxOffsetsPerTriggerHasBeenSet = false;
  bool m_minPartitionsHasBeenSet = false;
  bool m_includeHeadersHasBeenSet = false;
  bool m_addRecordTimestampHasBeenSet = false;
  bool m_emitConsumerLagMetricsHasBeenSet = false;
  bool m_startingTimestampHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws