SubscribeToShardEventStream.h

 
#pragma once
#include <aws/kinesis/Kinesis_EXPORTS.h>
#include <aws/kinesis/model/SubscribeToShardEvent.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Kinesis {
namespace Model {
 
class SubscribeToShardEventStream {
 public:
  AWS_KINESIS_API SubscribeToShardEventStream() = default;
  AWS_KINESIS_API SubscribeToShardEventStream(Aws::Utils::Json::JsonView jsonValue);
  AWS_KINESIS_API SubscribeToShardEventStream& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KINESIS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const SubscribeToShardEvent& GetSubscribeToShardEvent() const { return m_subscribeToShardEvent; }
  inline bool SubscribeToShardEventHasBeenSet() const { return m_subscribeToShardEventHasBeenSet; }
  template <typename SubscribeToShardEventT = SubscribeToShardEvent>
  void SetSubscribeToShardEvent(SubscribeToShardEventT&& value) {
    m_subscribeToShardEventHasBeenSet = true;
    m_subscribeToShardEvent = std::forward<SubscribeToShardEventT>(value);
  }
  template <typename SubscribeToShardEventT = SubscribeToShardEvent>
  SubscribeToShardEventStream& WithSubscribeToShardEvent(SubscribeToShardEventT&& value) {
    SetSubscribeToShardEvent(std::forward<SubscribeToShardEventT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetResourceNotFoundException() const { return m_resourceNotFoundException; }
  inline bool ResourceNotFoundExceptionHasBeenSet() const { return m_resourceNotFoundExceptionHasBeenSet; }
  template <typename ResourceNotFoundExceptionT = KinesisError>
  void SetResourceNotFoundException(ResourceNotFoundExceptionT&& value) {
    m_resourceNotFoundExceptionHasBeenSet = true;
    m_resourceNotFoundException = std::forward<ResourceNotFoundExceptionT>(value);
  }
  template <typename ResourceNotFoundExceptionT = KinesisError>
  SubscribeToShardEventStream& WithResourceNotFoundException(ResourceNotFoundExceptionT&& value) {
    SetResourceNotFoundException(std::forward<ResourceNotFoundExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetResourceInUseException() const { return m_resourceInUseException; }
  inline bool ResourceInUseExceptionHasBeenSet() const { return m_resourceInUseExceptionHasBeenSet; }
  template <typename ResourceInUseExceptionT = KinesisError>
  void SetResourceInUseException(ResourceInUseExceptionT&& value) {
    m_resourceInUseExceptionHasBeenSet = true;
    m_resourceInUseException = std::forward<ResourceInUseExceptionT>(value);
  }
  template <typename ResourceInUseExceptionT = KinesisError>
  SubscribeToShardEventStream& WithResourceInUseException(ResourceInUseExceptionT&& value) {
    SetResourceInUseException(std::forward<ResourceInUseExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSDisabledException() const { return m_kMSDisabledException; }
  inline bool KMSDisabledExceptionHasBeenSet() const { return m_kMSDisabledExceptionHasBeenSet; }
  template <typename KMSDisabledExceptionT = KinesisError>
  void SetKMSDisabledException(KMSDisabledExceptionT&& value) {
    m_kMSDisabledExceptionHasBeenSet = true;
    m_kMSDisabledException = std::forward<KMSDisabledExceptionT>(value);
  }
  template <typename KMSDisabledExceptionT = KinesisError>
  SubscribeToShardEventStream& WithKMSDisabledException(KMSDisabledExceptionT&& value) {
    SetKMSDisabledException(std::forward<KMSDisabledExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSInvalidStateException() const { return m_kMSInvalidStateException; }
  inline bool KMSInvalidStateExceptionHasBeenSet() const { return m_kMSInvalidStateExceptionHasBeenSet; }
  template <typename KMSInvalidStateExceptionT = KinesisError>
  void SetKMSInvalidStateException(KMSInvalidStateExceptionT&& value) {
    m_kMSInvalidStateExceptionHasBeenSet = true;
    m_kMSInvalidStateException = std::forward<KMSInvalidStateExceptionT>(value);
  }
  template <typename KMSInvalidStateExceptionT = KinesisError>
  SubscribeToShardEventStream& WithKMSInvalidStateException(KMSInvalidStateExceptionT&& value) {
    SetKMSInvalidStateException(std::forward<KMSInvalidStateExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSAccessDeniedException() const { return m_kMSAccessDeniedException; }
  inline bool KMSAccessDeniedExceptionHasBeenSet() const { return m_kMSAccessDeniedExceptionHasBeenSet; }
  template <typename KMSAccessDeniedExceptionT = KinesisError>
  void SetKMSAccessDeniedException(KMSAccessDeniedExceptionT&& value) {
    m_kMSAccessDeniedExceptionHasBeenSet = true;
    m_kMSAccessDeniedException = std::forward<KMSAccessDeniedExceptionT>(value);
  }
  template <typename KMSAccessDeniedExceptionT = KinesisError>
  SubscribeToShardEventStream& WithKMSAccessDeniedException(KMSAccessDeniedExceptionT&& value) {
    SetKMSAccessDeniedException(std::forward<KMSAccessDeniedExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSNotFoundException() const { return m_kMSNotFoundException; }
  inline bool KMSNotFoundExceptionHasBeenSet() const { return m_kMSNotFoundExceptionHasBeenSet; }
  template <typename KMSNotFoundExceptionT = KinesisError>
  void SetKMSNotFoundException(KMSNotFoundExceptionT&& value) {
    m_kMSNotFoundExceptionHasBeenSet = true;
    m_kMSNotFoundException = std::forward<KMSNotFoundExceptionT>(value);
  }
  template <typename KMSNotFoundExceptionT = KinesisError>
  SubscribeToShardEventStream& WithKMSNotFoundException(KMSNotFoundExceptionT&& value) {
    SetKMSNotFoundException(std::forward<KMSNotFoundExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSOptInRequired() const { return m_kMSOptInRequired; }
  inline bool KMSOptInRequiredHasBeenSet() const { return m_kMSOptInRequiredHasBeenSet; }
  template <typename KMSOptInRequiredT = KinesisError>
  void SetKMSOptInRequired(KMSOptInRequiredT&& value) {
    m_kMSOptInRequiredHasBeenSet = true;
    m_kMSOptInRequired = std::forward<KMSOptInRequiredT>(value);
  }
  template <typename KMSOptInRequiredT = KinesisError>
  SubscribeToShardEventStream& WithKMSOptInRequired(KMSOptInRequiredT&& value) {
    SetKMSOptInRequired(std::forward<KMSOptInRequiredT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetKMSThrottlingException() const { return m_kMSThrottlingException; }
  inline bool KMSThrottlingExceptionHasBeenSet() const { return m_kMSThrottlingExceptionHasBeenSet; }
  template <typename KMSThrottlingExceptionT = KinesisError>
  void SetKMSThrottlingException(KMSThrottlingExceptionT&& value) {
    m_kMSThrottlingExceptionHasBeenSet = true;
    m_kMSThrottlingException = std::forward<KMSThrottlingExceptionT>(value);
  }
  template <typename KMSThrottlingExceptionT = KinesisError>
  SubscribeToShardEventStream& WithKMSThrottlingException(KMSThrottlingExceptionT&& value) {
    SetKMSThrottlingException(std::forward<KMSThrottlingExceptionT>(value));
    return *this;
  }
 
 
  inline const KinesisError& GetInternalFailureException() const { return m_internalFailureException; }
  inline bool InternalFailureExceptionHasBeenSet() const { return m_internalFailureExceptionHasBeenSet; }
  template <typename InternalFailureExceptionT = KinesisError>
  void SetInternalFailureException(InternalFailureExceptionT&& value) {
    m_internalFailureExceptionHasBeenSet = true;
    m_internalFailureException = std::forward<InternalFailureExceptionT>(value);
  }
  template <typename InternalFailureExceptionT = KinesisError>
  SubscribeToShardEventStream& WithInternalFailureException(InternalFailureExceptionT&& value) {
    SetInternalFailureException(std::forward<InternalFailureExceptionT>(value));
    return *this;
  }
 private:
  SubscribeToShardEvent m_subscribeToShardEvent;
 
  KinesisError m_resourceNotFoundException;
 
  KinesisError m_resourceInUseException;
 
  KinesisError m_kMSDisabledException;
 
  KinesisError m_kMSInvalidStateException;
 
  KinesisError m_kMSAccessDeniedException;
 
  KinesisError m_kMSNotFoundException;
 
  KinesisError m_kMSOptInRequired;
 
  KinesisError m_kMSThrottlingException;
 
  KinesisError m_internalFailureException;
  bool m_subscribeToShardEventHasBeenSet = false;
  bool m_resourceNotFoundExceptionHasBeenSet = false;
  bool m_resourceInUseExceptionHasBeenSet = false;
  bool m_kMSDisabledExceptionHasBeenSet = false;
  bool m_kMSInvalidStateExceptionHasBeenSet = false;
  bool m_kMSAccessDeniedExceptionHasBeenSet = false;
  bool m_kMSNotFoundExceptionHasBeenSet = false;
  bool m_kMSOptInRequiredHasBeenSet = false;
  bool m_kMSThrottlingExceptionHasBeenSet = false;
  bool m_internalFailureExceptionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Kinesis
}  // namespace Aws