UpdateEventSourceMappingRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lambda/LambdaRequest.h>
#include <aws/lambda/Lambda_EXPORTS.h>
#include <aws/lambda/model/AmazonManagedKafkaEventSourceConfig.h>
#include <aws/lambda/model/DestinationConfig.h>
#include <aws/lambda/model/DocumentDBEventSourceConfig.h>
#include <aws/lambda/model/EventSourceMappingMetricsConfig.h>
#include <aws/lambda/model/FilterCriteria.h>
#include <aws/lambda/model/FunctionResponseType.h>
#include <aws/lambda/model/ProvisionedPollerConfig.h>
#include <aws/lambda/model/ScalingConfig.h>
#include <aws/lambda/model/SelfManagedKafkaEventSourceConfig.h>
#include <aws/lambda/model/SourceAccessConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Lambda {
namespace Model {
 
class UpdateEventSourceMappingRequest : public LambdaRequest {
 public:
  AWS_LAMBDA_API UpdateEventSourceMappingRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "UpdateEventSourceMapping"; }
 
  AWS_LAMBDA_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetUUID() const { return m_uUID; }
  inline bool UUIDHasBeenSet() const { return m_uUIDHasBeenSet; }
  template <typename UUIDT = Aws::String>
  void SetUUID(UUIDT&& value) {
    m_uUIDHasBeenSet = true;
    m_uUID = std::forward<UUIDT>(value);
  }
  template <typename UUIDT = Aws::String>
  UpdateEventSourceMappingRequest& WithUUID(UUIDT&& value) {
    SetUUID(std::forward<UUIDT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFunctionName() const { return m_functionName; }
  inline bool FunctionNameHasBeenSet() const { return m_functionNameHasBeenSet; }
  template <typename FunctionNameT = Aws::String>
  void SetFunctionName(FunctionNameT&& value) {
    m_functionNameHasBeenSet = true;
    m_functionName = std::forward<FunctionNameT>(value);
  }
  template <typename FunctionNameT = Aws::String>
  UpdateEventSourceMappingRequest& WithFunctionName(FunctionNameT&& value) {
    SetFunctionName(std::forward<FunctionNameT>(value));
    return *this;
  }
 
 
  inline bool GetEnabled() const { return m_enabled; }
  inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
  inline void SetEnabled(bool value) {
    m_enabledHasBeenSet = true;
    m_enabled = value;
  }
  inline UpdateEventSourceMappingRequest& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline int GetBatchSize() const { return m_batchSize; }
  inline bool BatchSizeHasBeenSet() const { return m_batchSizeHasBeenSet; }
  inline void SetBatchSize(int value) {
    m_batchSizeHasBeenSet = true;
    m_batchSize = value;
  }
  inline UpdateEventSourceMappingRequest& WithBatchSize(int value) {
    SetBatchSize(value);
    return *this;
  }
 
 
  inline const FilterCriteria& GetFilterCriteria() const { return m_filterCriteria; }
  inline bool FilterCriteriaHasBeenSet() const { return m_filterCriteriaHasBeenSet; }
  template <typename FilterCriteriaT = FilterCriteria>
  void SetFilterCriteria(FilterCriteriaT&& value) {
    m_filterCriteriaHasBeenSet = true;
    m_filterCriteria = std::forward<FilterCriteriaT>(value);
  }
  template <typename FilterCriteriaT = FilterCriteria>
  UpdateEventSourceMappingRequest& WithFilterCriteria(FilterCriteriaT&& value) {
    SetFilterCriteria(std::forward<FilterCriteriaT>(value));
    return *this;
  }
 
 
  inline int GetMaximumBatchingWindowInSeconds() const { return m_maximumBatchingWindowInSeconds; }
  inline bool MaximumBatchingWindowInSecondsHasBeenSet() const { return m_maximumBatchingWindowInSecondsHasBeenSet; }
  inline void SetMaximumBatchingWindowInSeconds(int value) {
    m_maximumBatchingWindowInSecondsHasBeenSet = true;
    m_maximumBatchingWindowInSeconds = value;
  }
  inline UpdateEventSourceMappingRequest& WithMaximumBatchingWindowInSeconds(int value) {
    SetMaximumBatchingWindowInSeconds(value);
    return *this;
  }
 
 
  inline const DestinationConfig& GetDestinationConfig() const { return m_destinationConfig; }
  inline bool DestinationConfigHasBeenSet() const { return m_destinationConfigHasBeenSet; }
  template <typename DestinationConfigT = DestinationConfig>
  void SetDestinationConfig(DestinationConfigT&& value) {
    m_destinationConfigHasBeenSet = true;
    m_destinationConfig = std::forward<DestinationConfigT>(value);
  }
  template <typename DestinationConfigT = DestinationConfig>
  UpdateEventSourceMappingRequest& WithDestinationConfig(DestinationConfigT&& value) {
    SetDestinationConfig(std::forward<DestinationConfigT>(value));
    return *this;
  }
 
 
  inline int GetMaximumRecordAgeInSeconds() const { return m_maximumRecordAgeInSeconds; }
  inline bool MaximumRecordAgeInSecondsHasBeenSet() const { return m_maximumRecordAgeInSecondsHasBeenSet; }
  inline void SetMaximumRecordAgeInSeconds(int value) {
    m_maximumRecordAgeInSecondsHasBeenSet = true;
    m_maximumRecordAgeInSeconds = value;
  }
  inline UpdateEventSourceMappingRequest& WithMaximumRecordAgeInSeconds(int value) {
    SetMaximumRecordAgeInSeconds(value);
    return *this;
  }
 
 
  inline bool GetBisectBatchOnFunctionError() const { return m_bisectBatchOnFunctionError; }
  inline bool BisectBatchOnFunctionErrorHasBeenSet() const { return m_bisectBatchOnFunctionErrorHasBeenSet; }
  inline void SetBisectBatchOnFunctionError(bool value) {
    m_bisectBatchOnFunctionErrorHasBeenSet = true;
    m_bisectBatchOnFunctionError = value;
  }
  inline UpdateEventSourceMappingRequest& WithBisectBatchOnFunctionError(bool value) {
    SetBisectBatchOnFunctionError(value);
    return *this;
  }
 
 
  inline int GetMaximumRetryAttempts() const { return m_maximumRetryAttempts; }
  inline bool MaximumRetryAttemptsHasBeenSet() const { return m_maximumRetryAttemptsHasBeenSet; }
  inline void SetMaximumRetryAttempts(int value) {
    m_maximumRetryAttemptsHasBeenSet = true;
    m_maximumRetryAttempts = value;
  }
  inline UpdateEventSourceMappingRequest& WithMaximumRetryAttempts(int value) {
    SetMaximumRetryAttempts(value);
    return *this;
  }
 
 
  inline int GetParallelizationFactor() const { return m_parallelizationFactor; }
  inline bool ParallelizationFactorHasBeenSet() const { return m_parallelizationFactorHasBeenSet; }
  inline void SetParallelizationFactor(int value) {
    m_parallelizationFactorHasBeenSet = true;
    m_parallelizationFactor = value;
  }
  inline UpdateEventSourceMappingRequest& WithParallelizationFactor(int value) {
    SetParallelizationFactor(value);
    return *this;
  }
 
 
  inline const Aws::Vector<SourceAccessConfiguration>& GetSourceAccessConfigurations() const { return m_sourceAccessConfigurations; }
  inline bool SourceAccessConfigurationsHasBeenSet() const { return m_sourceAccessConfigurationsHasBeenSet; }
  template <typename SourceAccessConfigurationsT = Aws::Vector<SourceAccessConfiguration>>
  void SetSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    m_sourceAccessConfigurationsHasBeenSet = true;
    m_sourceAccessConfigurations = std::forward<SourceAccessConfigurationsT>(value);
  }
  template <typename SourceAccessConfigurationsT = Aws::Vector<SourceAccessConfiguration>>
  UpdateEventSourceMappingRequest& WithSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    SetSourceAccessConfigurations(std::forward<SourceAccessConfigurationsT>(value));
    return *this;
  }
  template <typename SourceAccessConfigurationsT = SourceAccessConfiguration>
  UpdateEventSourceMappingRequest& AddSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    m_sourceAccessConfigurationsHasBeenSet = true;
    m_sourceAccessConfigurations.emplace_back(std::forward<SourceAccessConfigurationsT>(value));
    return *this;
  }
 
 
  inline int GetTumblingWindowInSeconds() const { return m_tumblingWindowInSeconds; }
  inline bool TumblingWindowInSecondsHasBeenSet() const { return m_tumblingWindowInSecondsHasBeenSet; }
  inline void SetTumblingWindowInSeconds(int value) {
    m_tumblingWindowInSecondsHasBeenSet = true;
    m_tumblingWindowInSeconds = value;
  }
  inline UpdateEventSourceMappingRequest& WithTumblingWindowInSeconds(int value) {
    SetTumblingWindowInSeconds(value);
    return *this;
  }
 
 
  inline const Aws::Vector<FunctionResponseType>& GetFunctionResponseTypes() const { return m_functionResponseTypes; }
  inline bool FunctionResponseTypesHasBeenSet() const { return m_functionResponseTypesHasBeenSet; }
  template <typename FunctionResponseTypesT = Aws::Vector<FunctionResponseType>>
  void SetFunctionResponseTypes(FunctionResponseTypesT&& value) {
    m_functionResponseTypesHasBeenSet = true;
    m_functionResponseTypes = std::forward<FunctionResponseTypesT>(value);
  }
  template <typename FunctionResponseTypesT = Aws::Vector<FunctionResponseType>>
  UpdateEventSourceMappingRequest& WithFunctionResponseTypes(FunctionResponseTypesT&& value) {
    SetFunctionResponseTypes(std::forward<FunctionResponseTypesT>(value));
    return *this;
  }
  inline UpdateEventSourceMappingRequest& AddFunctionResponseTypes(FunctionResponseType value) {
    m_functionResponseTypesHasBeenSet = true;
    m_functionResponseTypes.push_back(value);
    return *this;
  }
 
 
  inline const ScalingConfig& GetScalingConfig() const { return m_scalingConfig; }
  inline bool ScalingConfigHasBeenSet() const { return m_scalingConfigHasBeenSet; }
  template <typename ScalingConfigT = ScalingConfig>
  void SetScalingConfig(ScalingConfigT&& value) {
    m_scalingConfigHasBeenSet = true;
    m_scalingConfig = std::forward<ScalingConfigT>(value);
  }
  template <typename ScalingConfigT = ScalingConfig>
  UpdateEventSourceMappingRequest& WithScalingConfig(ScalingConfigT&& value) {
    SetScalingConfig(std::forward<ScalingConfigT>(value));
    return *this;
  }
 
 
  inline const AmazonManagedKafkaEventSourceConfig& GetAmazonManagedKafkaEventSourceConfig() const {
    return m_amazonManagedKafkaEventSourceConfig;
  }
  inline bool AmazonManagedKafkaEventSourceConfigHasBeenSet() const { return m_amazonManagedKafkaEventSourceConfigHasBeenSet; }
  template <typename AmazonManagedKafkaEventSourceConfigT = AmazonManagedKafkaEventSourceConfig>
  void SetAmazonManagedKafkaEventSourceConfig(AmazonManagedKafkaEventSourceConfigT&& value) {
    m_amazonManagedKafkaEventSourceConfigHasBeenSet = true;
    m_amazonManagedKafkaEventSourceConfig = std::forward<AmazonManagedKafkaEventSourceConfigT>(value);
  }
  template <typename AmazonManagedKafkaEventSourceConfigT = AmazonManagedKafkaEventSourceConfig>
  UpdateEventSourceMappingRequest& WithAmazonManagedKafkaEventSourceConfig(AmazonManagedKafkaEventSourceConfigT&& value) {
    SetAmazonManagedKafkaEventSourceConfig(std::forward<AmazonManagedKafkaEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const SelfManagedKafkaEventSourceConfig& GetSelfManagedKafkaEventSourceConfig() const {
    return m_selfManagedKafkaEventSourceConfig;
  }
  inline bool SelfManagedKafkaEventSourceConfigHasBeenSet() const { return m_selfManagedKafkaEventSourceConfigHasBeenSet; }
  template <typename SelfManagedKafkaEventSourceConfigT = SelfManagedKafkaEventSourceConfig>
  void SetSelfManagedKafkaEventSourceConfig(SelfManagedKafkaEventSourceConfigT&& value) {
    m_selfManagedKafkaEventSourceConfigHasBeenSet = true;
    m_selfManagedKafkaEventSourceConfig = std::forward<SelfManagedKafkaEventSourceConfigT>(value);
  }
  template <typename SelfManagedKafkaEventSourceConfigT = SelfManagedKafkaEventSourceConfig>
  UpdateEventSourceMappingRequest& WithSelfManagedKafkaEventSourceConfig(SelfManagedKafkaEventSourceConfigT&& value) {
    SetSelfManagedKafkaEventSourceConfig(std::forward<SelfManagedKafkaEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const DocumentDBEventSourceConfig& GetDocumentDBEventSourceConfig() const { return m_documentDBEventSourceConfig; }
  inline bool DocumentDBEventSourceConfigHasBeenSet() const { return m_documentDBEventSourceConfigHasBeenSet; }
  template <typename DocumentDBEventSourceConfigT = DocumentDBEventSourceConfig>
  void SetDocumentDBEventSourceConfig(DocumentDBEventSourceConfigT&& value) {
    m_documentDBEventSourceConfigHasBeenSet = true;
    m_documentDBEventSourceConfig = std::forward<DocumentDBEventSourceConfigT>(value);
  }
  template <typename DocumentDBEventSourceConfigT = DocumentDBEventSourceConfig>
  UpdateEventSourceMappingRequest& WithDocumentDBEventSourceConfig(DocumentDBEventSourceConfigT&& value) {
    SetDocumentDBEventSourceConfig(std::forward<DocumentDBEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKMSKeyArn() const { return m_kMSKeyArn; }
  inline bool KMSKeyArnHasBeenSet() const { return m_kMSKeyArnHasBeenSet; }
  template <typename KMSKeyArnT = Aws::String>
  void SetKMSKeyArn(KMSKeyArnT&& value) {
    m_kMSKeyArnHasBeenSet = true;
    m_kMSKeyArn = std::forward<KMSKeyArnT>(value);
  }
  template <typename KMSKeyArnT = Aws::String>
  UpdateEventSourceMappingRequest& WithKMSKeyArn(KMSKeyArnT&& value) {
    SetKMSKeyArn(std::forward<KMSKeyArnT>(value));
    return *this;
  }
 
 
  inline const EventSourceMappingMetricsConfig& GetMetricsConfig() const { return m_metricsConfig; }
  inline bool MetricsConfigHasBeenSet() const { return m_metricsConfigHasBeenSet; }
  template <typename MetricsConfigT = EventSourceMappingMetricsConfig>
  void SetMetricsConfig(MetricsConfigT&& value) {
    m_metricsConfigHasBeenSet = true;
    m_metricsConfig = std::forward<MetricsConfigT>(value);
  }
  template <typename MetricsConfigT = EventSourceMappingMetricsConfig>
  UpdateEventSourceMappingRequest& WithMetricsConfig(MetricsConfigT&& value) {
    SetMetricsConfig(std::forward<MetricsConfigT>(value));
    return *this;
  }
 
 
  inline const ProvisionedPollerConfig& GetProvisionedPollerConfig() const { return m_provisionedPollerConfig; }
  inline bool ProvisionedPollerConfigHasBeenSet() const { return m_provisionedPollerConfigHasBeenSet; }
  template <typename ProvisionedPollerConfigT = ProvisionedPollerConfig>
  void SetProvisionedPollerConfig(ProvisionedPollerConfigT&& value) {
    m_provisionedPollerConfigHasBeenSet = true;
    m_provisionedPollerConfig = std::forward<ProvisionedPollerConfigT>(value);
  }
  template <typename ProvisionedPollerConfigT = ProvisionedPollerConfig>
  UpdateEventSourceMappingRequest& WithProvisionedPollerConfig(ProvisionedPollerConfigT&& value) {
    SetProvisionedPollerConfig(std::forward<ProvisionedPollerConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_uUID;
  bool m_uUIDHasBeenSet = false;
 
  Aws::String m_functionName;
  bool m_functionNameHasBeenSet = false;
 
  bool m_enabled{false};
  bool m_enabledHasBeenSet = false;
 
  int m_batchSize{0};
  bool m_batchSizeHasBeenSet = false;
 
  FilterCriteria m_filterCriteria;
  bool m_filterCriteriaHasBeenSet = false;
 
  int m_maximumBatchingWindowInSeconds{0};
  bool m_maximumBatchingWindowInSecondsHasBeenSet = false;
 
  DestinationConfig m_destinationConfig;
  bool m_destinationConfigHasBeenSet = false;
 
  int m_maximumRecordAgeInSeconds{0};
  bool m_maximumRecordAgeInSecondsHasBeenSet = false;
 
  bool m_bisectBatchOnFunctionError{false};
  bool m_bisectBatchOnFunctionErrorHasBeenSet = false;
 
  int m_maximumRetryAttempts{0};
  bool m_maximumRetryAttemptsHasBeenSet = false;
 
  int m_parallelizationFactor{0};
  bool m_parallelizationFactorHasBeenSet = false;
 
  Aws::Vector<SourceAccessConfiguration> m_sourceAccessConfigurations;
  bool m_sourceAccessConfigurationsHasBeenSet = false;
 
  int m_tumblingWindowInSeconds{0};
  bool m_tumblingWindowInSecondsHasBeenSet = false;
 
  Aws::Vector<FunctionResponseType> m_functionResponseTypes;
  bool m_functionResponseTypesHasBeenSet = false;
 
  ScalingConfig m_scalingConfig;
  bool m_scalingConfigHasBeenSet = false;
 
  AmazonManagedKafkaEventSourceConfig m_amazonManagedKafkaEventSourceConfig;
  bool m_amazonManagedKafkaEventSourceConfigHasBeenSet = false;
 
  SelfManagedKafkaEventSourceConfig m_selfManagedKafkaEventSourceConfig;
  bool m_selfManagedKafkaEventSourceConfigHasBeenSet = false;
 
  DocumentDBEventSourceConfig m_documentDBEventSourceConfig;
  bool m_documentDBEventSourceConfigHasBeenSet = false;
 
  Aws::String m_kMSKeyArn;
  bool m_kMSKeyArnHasBeenSet = false;
 
  EventSourceMappingMetricsConfig m_metricsConfig;
  bool m_metricsConfigHasBeenSet = false;
 
  ProvisionedPollerConfig m_provisionedPollerConfig;
  bool m_provisionedPollerConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lambda
}  // namespace Aws