KinesisStreamingSourceOptions.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/StartingPosition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class KinesisStreamingSourceOptions {
 public:
  AWS_GLUE_API KinesisStreamingSourceOptions() = default;
  AWS_GLUE_API KinesisStreamingSourceOptions(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API KinesisStreamingSourceOptions& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetEndpointUrl() const { return m_endpointUrl; }
  inline bool EndpointUrlHasBeenSet() const { return m_endpointUrlHasBeenSet; }
  template <typename EndpointUrlT = Aws::String>
  void SetEndpointUrl(EndpointUrlT&& value) {
    m_endpointUrlHasBeenSet = true;
    m_endpointUrl = std::forward<EndpointUrlT>(value);
  }
  template <typename EndpointUrlT = Aws::String>
  KinesisStreamingSourceOptions& WithEndpointUrl(EndpointUrlT&& value) {
    SetEndpointUrl(std::forward<EndpointUrlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStreamName() const { return m_streamName; }
  inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
  template <typename StreamNameT = Aws::String>
  void SetStreamName(StreamNameT&& value) {
    m_streamNameHasBeenSet = true;
    m_streamName = std::forward<StreamNameT>(value);
  }
  template <typename StreamNameT = Aws::String>
  KinesisStreamingSourceOptions& WithStreamName(StreamNameT&& value) {
    SetStreamName(std::forward<StreamNameT>(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>
  KinesisStreamingSourceOptions& 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>
  KinesisStreamingSourceOptions& WithDelimiter(DelimiterT&& value) {
    SetDelimiter(std::forward<DelimiterT>(value));
    return *this;
  }
 
 
  inline StartingPosition GetStartingPosition() const { return m_startingPosition; }
  inline bool StartingPositionHasBeenSet() const { return m_startingPositionHasBeenSet; }
  inline void SetStartingPosition(StartingPosition value) {
    m_startingPositionHasBeenSet = true;
    m_startingPosition = value;
  }
  inline KinesisStreamingSourceOptions& WithStartingPosition(StartingPosition value) {
    SetStartingPosition(value);
    return *this;
  }
 
 
  inline long long GetMaxFetchTimeInMs() const { return m_maxFetchTimeInMs; }
  inline bool MaxFetchTimeInMsHasBeenSet() const { return m_maxFetchTimeInMsHasBeenSet; }
  inline void SetMaxFetchTimeInMs(long long value) {
    m_maxFetchTimeInMsHasBeenSet = true;
    m_maxFetchTimeInMs = value;
  }
  inline KinesisStreamingSourceOptions& WithMaxFetchTimeInMs(long long value) {
    SetMaxFetchTimeInMs(value);
    return *this;
  }
 
 
  inline long long GetMaxFetchRecordsPerShard() const { return m_maxFetchRecordsPerShard; }
  inline bool MaxFetchRecordsPerShardHasBeenSet() const { return m_maxFetchRecordsPerShardHasBeenSet; }
  inline void SetMaxFetchRecordsPerShard(long long value) {
    m_maxFetchRecordsPerShardHasBeenSet = true;
    m_maxFetchRecordsPerShard = value;
  }
  inline KinesisStreamingSourceOptions& WithMaxFetchRecordsPerShard(long long value) {
    SetMaxFetchRecordsPerShard(value);
    return *this;
  }
 
 
  inline long long GetMaxRecordPerRead() const { return m_maxRecordPerRead; }
  inline bool MaxRecordPerReadHasBeenSet() const { return m_maxRecordPerReadHasBeenSet; }
  inline void SetMaxRecordPerRead(long long value) {
    m_maxRecordPerReadHasBeenSet = true;
    m_maxRecordPerRead = value;
  }
  inline KinesisStreamingSourceOptions& WithMaxRecordPerRead(long long value) {
    SetMaxRecordPerRead(value);
    return *this;
  }
 
 
  inline bool GetAddIdleTimeBetweenReads() const { return m_addIdleTimeBetweenReads; }
  inline bool AddIdleTimeBetweenReadsHasBeenSet() const { return m_addIdleTimeBetweenReadsHasBeenSet; }
  inline void SetAddIdleTimeBetweenReads(bool value) {
    m_addIdleTimeBetweenReadsHasBeenSet = true;
    m_addIdleTimeBetweenReads = value;
  }
  inline KinesisStreamingSourceOptions& WithAddIdleTimeBetweenReads(bool value) {
    SetAddIdleTimeBetweenReads(value);
    return *this;
  }
 
 
  inline long long GetIdleTimeBetweenReadsInMs() const { return m_idleTimeBetweenReadsInMs; }
  inline bool IdleTimeBetweenReadsInMsHasBeenSet() const { return m_idleTimeBetweenReadsInMsHasBeenSet; }
  inline void SetIdleTimeBetweenReadsInMs(long long value) {
    m_idleTimeBetweenReadsInMsHasBeenSet = true;
    m_idleTimeBetweenReadsInMs = value;
  }
  inline KinesisStreamingSourceOptions& WithIdleTimeBetweenReadsInMs(long long value) {
    SetIdleTimeBetweenReadsInMs(value);
    return *this;
  }
 
 
  inline long long GetDescribeShardInterval() const { return m_describeShardInterval; }
  inline bool DescribeShardIntervalHasBeenSet() const { return m_describeShardIntervalHasBeenSet; }
  inline void SetDescribeShardInterval(long long value) {
    m_describeShardIntervalHasBeenSet = true;
    m_describeShardInterval = value;
  }
  inline KinesisStreamingSourceOptions& WithDescribeShardInterval(long long value) {
    SetDescribeShardInterval(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 KinesisStreamingSourceOptions& 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 KinesisStreamingSourceOptions& WithRetryIntervalMs(long long value) {
    SetRetryIntervalMs(value);
    return *this;
  }
 
 
  inline long long GetMaxRetryIntervalMs() const { return m_maxRetryIntervalMs; }
  inline bool MaxRetryIntervalMsHasBeenSet() const { return m_maxRetryIntervalMsHasBeenSet; }
  inline void SetMaxRetryIntervalMs(long long value) {
    m_maxRetryIntervalMsHasBeenSet = true;
    m_maxRetryIntervalMs = value;
  }
  inline KinesisStreamingSourceOptions& WithMaxRetryIntervalMs(long long value) {
    SetMaxRetryIntervalMs(value);
    return *this;
  }
 
 
  inline bool GetAvoidEmptyBatches() const { return m_avoidEmptyBatches; }
  inline bool AvoidEmptyBatchesHasBeenSet() const { return m_avoidEmptyBatchesHasBeenSet; }
  inline void SetAvoidEmptyBatches(bool value) {
    m_avoidEmptyBatchesHasBeenSet = true;
    m_avoidEmptyBatches = value;
  }
  inline KinesisStreamingSourceOptions& WithAvoidEmptyBatches(bool value) {
    SetAvoidEmptyBatches(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStreamArn() const { return m_streamArn; }
  inline bool StreamArnHasBeenSet() const { return m_streamArnHasBeenSet; }
  template <typename StreamArnT = Aws::String>
  void SetStreamArn(StreamArnT&& value) {
    m_streamArnHasBeenSet = true;
    m_streamArn = std::forward<StreamArnT>(value);
  }
  template <typename StreamArnT = Aws::String>
  KinesisStreamingSourceOptions& WithStreamArn(StreamArnT&& value) {
    SetStreamArn(std::forward<StreamArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  KinesisStreamingSourceOptions& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleSessionName() const { return m_roleSessionName; }
  inline bool RoleSessionNameHasBeenSet() const { return m_roleSessionNameHasBeenSet; }
  template <typename RoleSessionNameT = Aws::String>
  void SetRoleSessionName(RoleSessionNameT&& value) {
    m_roleSessionNameHasBeenSet = true;
    m_roleSessionName = std::forward<RoleSessionNameT>(value);
  }
  template <typename RoleSessionNameT = Aws::String>
  KinesisStreamingSourceOptions& WithRoleSessionName(RoleSessionNameT&& value) {
    SetRoleSessionName(std::forward<RoleSessionNameT>(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>
  KinesisStreamingSourceOptions& 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>
  KinesisStreamingSourceOptions& 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>
  KinesisStreamingSourceOptions& WithStartingTimestamp(StartingTimestampT&& value) {
    SetStartingTimestamp(std::forward<StartingTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFanoutConsumerARN() const { return m_fanoutConsumerARN; }
  inline bool FanoutConsumerARNHasBeenSet() const { return m_fanoutConsumerARNHasBeenSet; }
  template <typename FanoutConsumerARNT = Aws::String>
  void SetFanoutConsumerARN(FanoutConsumerARNT&& value) {
    m_fanoutConsumerARNHasBeenSet = true;
    m_fanoutConsumerARN = std::forward<FanoutConsumerARNT>(value);
  }
  template <typename FanoutConsumerARNT = Aws::String>
  KinesisStreamingSourceOptions& WithFanoutConsumerARN(FanoutConsumerARNT&& value) {
    SetFanoutConsumerARN(std::forward<FanoutConsumerARNT>(value));
    return *this;
  }
 private:
  Aws::String m_endpointUrl;
 
  Aws::String m_streamName;
 
  Aws::String m_classification;
 
  Aws::String m_delimiter;
 
  StartingPosition m_startingPosition{StartingPosition::NOT_SET};
 
  long long m_maxFetchTimeInMs{0};
 
  long long m_maxFetchRecordsPerShard{0};
 
  long long m_maxRecordPerRead{0};
 
  bool m_addIdleTimeBetweenReads{false};
 
  long long m_idleTimeBetweenReadsInMs{0};
 
  long long m_describeShardInterval{0};
 
  int m_numRetries{0};
 
  long long m_retryIntervalMs{0};
 
  long long m_maxRetryIntervalMs{0};
 
  bool m_avoidEmptyBatches{false};
 
  Aws::String m_streamArn;
 
  Aws::String m_roleArn;
 
  Aws::String m_roleSessionName;
 
  Aws::String m_addRecordTimestamp;
 
  Aws::String m_emitConsumerLagMetrics;
 
  Aws::Utils::DateTime m_startingTimestamp{};
 
  Aws::String m_fanoutConsumerARN;
  bool m_endpointUrlHasBeenSet = false;
  bool m_streamNameHasBeenSet = false;
  bool m_classificationHasBeenSet = false;
  bool m_delimiterHasBeenSet = false;
  bool m_startingPositionHasBeenSet = false;
  bool m_maxFetchTimeInMsHasBeenSet = false;
  bool m_maxFetchRecordsPerShardHasBeenSet = false;
  bool m_maxRecordPerReadHasBeenSet = false;
  bool m_addIdleTimeBetweenReadsHasBeenSet = false;
  bool m_idleTimeBetweenReadsInMsHasBeenSet = false;
  bool m_describeShardIntervalHasBeenSet = false;
  bool m_numRetriesHasBeenSet = false;
  bool m_retryIntervalMsHasBeenSet = false;
  bool m_maxRetryIntervalMsHasBeenSet = false;
  bool m_avoidEmptyBatchesHasBeenSet = false;
  bool m_streamArnHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_roleSessionNameHasBeenSet = false;
  bool m_addRecordTimestampHasBeenSet = false;
  bool m_emitConsumerLagMetricsHasBeenSet = false;
  bool m_startingTimestampHasBeenSet = false;
  bool m_fanoutConsumerARNHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws