IngestConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ivs-realtime/Ivsrealtime_EXPORTS.h>
#include <aws/ivs-realtime/model/IngestConfigurationState.h>
#include <aws/ivs-realtime/model/IngestProtocol.h>
#include <aws/ivs-realtime/model/RedundantIngestCredential.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ivsrealtime {
namespace Model {
 
class IngestConfiguration {
 public:
  AWS_IVSREALTIME_API IngestConfiguration() = default;
  AWS_IVSREALTIME_API IngestConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_IVSREALTIME_API IngestConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IVSREALTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  IngestConfiguration& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  IngestConfiguration& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline IngestProtocol GetIngestProtocol() const { return m_ingestProtocol; }
  inline bool IngestProtocolHasBeenSet() const { return m_ingestProtocolHasBeenSet; }
  inline void SetIngestProtocol(IngestProtocol value) {
    m_ingestProtocolHasBeenSet = true;
    m_ingestProtocol = value;
  }
  inline IngestConfiguration& WithIngestProtocol(IngestProtocol value) {
    SetIngestProtocol(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStreamKey() const { return m_streamKey; }
  inline bool StreamKeyHasBeenSet() const { return m_streamKeyHasBeenSet; }
  template <typename StreamKeyT = Aws::String>
  void SetStreamKey(StreamKeyT&& value) {
    m_streamKeyHasBeenSet = true;
    m_streamKey = std::forward<StreamKeyT>(value);
  }
  template <typename StreamKeyT = Aws::String>
  IngestConfiguration& WithStreamKey(StreamKeyT&& value) {
    SetStreamKey(std::forward<StreamKeyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStageArn() const { return m_stageArn; }
  inline bool StageArnHasBeenSet() const { return m_stageArnHasBeenSet; }
  template <typename StageArnT = Aws::String>
  void SetStageArn(StageArnT&& value) {
    m_stageArnHasBeenSet = true;
    m_stageArn = std::forward<StageArnT>(value);
  }
  template <typename StageArnT = Aws::String>
  IngestConfiguration& WithStageArn(StageArnT&& value) {
    SetStageArn(std::forward<StageArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetParticipantId() const { return m_participantId; }
  inline bool ParticipantIdHasBeenSet() const { return m_participantIdHasBeenSet; }
  template <typename ParticipantIdT = Aws::String>
  void SetParticipantId(ParticipantIdT&& value) {
    m_participantIdHasBeenSet = true;
    m_participantId = std::forward<ParticipantIdT>(value);
  }
  template <typename ParticipantIdT = Aws::String>
  IngestConfiguration& WithParticipantId(ParticipantIdT&& value) {
    SetParticipantId(std::forward<ParticipantIdT>(value));
    return *this;
  }
 
 
  inline IngestConfigurationState GetState() const { return m_state; }
  inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
  inline void SetState(IngestConfigurationState value) {
    m_stateHasBeenSet = true;
    m_state = value;
  }
  inline IngestConfiguration& WithState(IngestConfigurationState value) {
    SetState(value);
    return *this;
  }
 
 
  inline const Aws::String& GetUserId() const { return m_userId; }
  inline bool UserIdHasBeenSet() const { return m_userIdHasBeenSet; }
  template <typename UserIdT = Aws::String>
  void SetUserId(UserIdT&& value) {
    m_userIdHasBeenSet = true;
    m_userId = std::forward<UserIdT>(value);
  }
  template <typename UserIdT = Aws::String>
  IngestConfiguration& WithUserId(UserIdT&& value) {
    SetUserId(std::forward<UserIdT>(value));
    return *this;
  }
 
 
  inline bool GetRedundantIngest() const { return m_redundantIngest; }
  inline bool RedundantIngestHasBeenSet() const { return m_redundantIngestHasBeenSet; }
  inline void SetRedundantIngest(bool value) {
    m_redundantIngestHasBeenSet = true;
    m_redundantIngest = value;
  }
  inline IngestConfiguration& WithRedundantIngest(bool value) {
    SetRedundantIngest(value);
    return *this;
  }
 
 
  inline const Aws::Vector<RedundantIngestCredential>& GetRedundantIngestCredentials() const { return m_redundantIngestCredentials; }
  inline bool RedundantIngestCredentialsHasBeenSet() const { return m_redundantIngestCredentialsHasBeenSet; }
  template <typename RedundantIngestCredentialsT = Aws::Vector<RedundantIngestCredential>>
  void SetRedundantIngestCredentials(RedundantIngestCredentialsT&& value) {
    m_redundantIngestCredentialsHasBeenSet = true;
    m_redundantIngestCredentials = std::forward<RedundantIngestCredentialsT>(value);
  }
  template <typename RedundantIngestCredentialsT = Aws::Vector<RedundantIngestCredential>>
  IngestConfiguration& WithRedundantIngestCredentials(RedundantIngestCredentialsT&& value) {
    SetRedundantIngestCredentials(std::forward<RedundantIngestCredentialsT>(value));
    return *this;
  }
  template <typename RedundantIngestCredentialsT = RedundantIngestCredential>
  IngestConfiguration& AddRedundantIngestCredentials(RedundantIngestCredentialsT&& value) {
    m_redundantIngestCredentialsHasBeenSet = true;
    m_redundantIngestCredentials.emplace_back(std::forward<RedundantIngestCredentialsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetAttributes() const { return m_attributes; }
  inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
  template <typename AttributesT = Aws::Map<Aws::String, Aws::String>>
  void SetAttributes(AttributesT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes = std::forward<AttributesT>(value);
  }
  template <typename AttributesT = Aws::Map<Aws::String, Aws::String>>
  IngestConfiguration& WithAttributes(AttributesT&& value) {
    SetAttributes(std::forward<AttributesT>(value));
    return *this;
  }
  template <typename AttributesKeyT = Aws::String, typename AttributesValueT = Aws::String>
  IngestConfiguration& AddAttributes(AttributesKeyT&& key, AttributesValueT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes.emplace(std::forward<AttributesKeyT>(key), std::forward<AttributesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  IngestConfiguration& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  IngestConfiguration& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_arn;
 
  IngestProtocol m_ingestProtocol{IngestProtocol::NOT_SET};
 
  Aws::String m_streamKey;
 
  Aws::String m_stageArn;
 
  Aws::String m_participantId;
 
  IngestConfigurationState m_state{IngestConfigurationState::NOT_SET};
 
  Aws::String m_userId;
 
  bool m_redundantIngest{false};
 
  Aws::Vector<RedundantIngestCredential> m_redundantIngestCredentials;
 
  Aws::Map<Aws::String, Aws::String> m_attributes;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
  bool m_nameHasBeenSet = false;
  bool m_arnHasBeenSet = false;
  bool m_ingestProtocolHasBeenSet = false;
  bool m_streamKeyHasBeenSet = false;
  bool m_stageArnHasBeenSet = false;
  bool m_participantIdHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_userIdHasBeenSet = false;
  bool m_redundantIngestHasBeenSet = false;
  bool m_redundantIngestCredentialsHasBeenSet = false;
  bool m_attributesHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ivsrealtime
}  // namespace Aws