KinesisStreamingSourceOptions.h

 
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/model/StartingPosition.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 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;}
  private:
 
    Aws::String m_endpointUrl;
    bool m_endpointUrlHasBeenSet = false;
 
    Aws::String m_streamName;
    bool m_streamNameHasBeenSet = false;
 
    Aws::String m_classification;
    bool m_classificationHasBeenSet = false;
 
    Aws::String m_delimiter;
    bool m_delimiterHasBeenSet = false;
 
    StartingPosition m_startingPosition{StartingPosition::NOT_SET};
    bool m_startingPositionHasBeenSet = false;
 
    long long m_maxFetchTimeInMs{0};
    bool m_maxFetchTimeInMsHasBeenSet = false;
 
    long long m_maxFetchRecordsPerShard{0};
    bool m_maxFetchRecordsPerShardHasBeenSet = false;
 
    long long m_maxRecordPerRead{0};
    bool m_maxRecordPerReadHasBeenSet = false;
 
    bool m_addIdleTimeBetweenReads{false};
    bool m_addIdleTimeBetweenReadsHasBeenSet = false;
 
    long long m_idleTimeBetweenReadsInMs{0};
    bool m_idleTimeBetweenReadsInMsHasBeenSet = false;
 
    long long m_describeShardInterval{0};
    bool m_describeShardIntervalHasBeenSet = false;
 
    int m_numRetries{0};
    bool m_numRetriesHasBeenSet = false;
 
    long long m_retryIntervalMs{0};
    bool m_retryIntervalMsHasBeenSet = false;
 
    long long m_maxRetryIntervalMs{0};
    bool m_maxRetryIntervalMsHasBeenSet = false;
 
    bool m_avoidEmptyBatches{false};
    bool m_avoidEmptyBatchesHasBeenSet = false;
 
    Aws::String m_streamArn;
    bool m_streamArnHasBeenSet = false;
 
    Aws::String m_roleArn;
    bool m_roleArnHasBeenSet = false;
 
    Aws::String m_roleSessionName;
    bool m_roleSessionNameHasBeenSet = 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