MsSmoothGroupSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/DestinationSettings.h>
#include <aws/mediaconvert/model/MsSmoothAdditionalManifest.h>
#include <aws/mediaconvert/model/MsSmoothAudioDeduplication.h>
#include <aws/mediaconvert/model/MsSmoothEncryptionSettings.h>
#include <aws/mediaconvert/model/MsSmoothFragmentLengthControl.h>
#include <aws/mediaconvert/model/MsSmoothManifestEncoding.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class MsSmoothGroupSettings {
 public:
  AWS_MEDIACONVERT_API MsSmoothGroupSettings() = default;
  AWS_MEDIACONVERT_API MsSmoothGroupSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API MsSmoothGroupSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<MsSmoothAdditionalManifest>& GetAdditionalManifests() const { return m_additionalManifests; }
  inline bool AdditionalManifestsHasBeenSet() const { return m_additionalManifestsHasBeenSet; }
  template <typename AdditionalManifestsT = Aws::Vector<MsSmoothAdditionalManifest>>
  void SetAdditionalManifests(AdditionalManifestsT&& value) {
    m_additionalManifestsHasBeenSet = true;
    m_additionalManifests = std::forward<AdditionalManifestsT>(value);
  }
  template <typename AdditionalManifestsT = Aws::Vector<MsSmoothAdditionalManifest>>
  MsSmoothGroupSettings& WithAdditionalManifests(AdditionalManifestsT&& value) {
    SetAdditionalManifests(std::forward<AdditionalManifestsT>(value));
    return *this;
  }
  template <typename AdditionalManifestsT = MsSmoothAdditionalManifest>
  MsSmoothGroupSettings& AddAdditionalManifests(AdditionalManifestsT&& value) {
    m_additionalManifestsHasBeenSet = true;
    m_additionalManifests.emplace_back(std::forward<AdditionalManifestsT>(value));
    return *this;
  }
 
 
  inline MsSmoothAudioDeduplication GetAudioDeduplication() const { return m_audioDeduplication; }
  inline bool AudioDeduplicationHasBeenSet() const { return m_audioDeduplicationHasBeenSet; }
  inline void SetAudioDeduplication(MsSmoothAudioDeduplication value) {
    m_audioDeduplicationHasBeenSet = true;
    m_audioDeduplication = value;
  }
  inline MsSmoothGroupSettings& WithAudioDeduplication(MsSmoothAudioDeduplication value) {
    SetAudioDeduplication(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDestination() const { return m_destination; }
  inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
  template <typename DestinationT = Aws::String>
  void SetDestination(DestinationT&& value) {
    m_destinationHasBeenSet = true;
    m_destination = std::forward<DestinationT>(value);
  }
  template <typename DestinationT = Aws::String>
  MsSmoothGroupSettings& WithDestination(DestinationT&& value) {
    SetDestination(std::forward<DestinationT>(value));
    return *this;
  }
 
 
  inline const DestinationSettings& GetDestinationSettings() const { return m_destinationSettings; }
  inline bool DestinationSettingsHasBeenSet() const { return m_destinationSettingsHasBeenSet; }
  template <typename DestinationSettingsT = DestinationSettings>
  void SetDestinationSettings(DestinationSettingsT&& value) {
    m_destinationSettingsHasBeenSet = true;
    m_destinationSettings = std::forward<DestinationSettingsT>(value);
  }
  template <typename DestinationSettingsT = DestinationSettings>
  MsSmoothGroupSettings& WithDestinationSettings(DestinationSettingsT&& value) {
    SetDestinationSettings(std::forward<DestinationSettingsT>(value));
    return *this;
  }
 
 
  inline const MsSmoothEncryptionSettings& GetEncryption() const { return m_encryption; }
  inline bool EncryptionHasBeenSet() const { return m_encryptionHasBeenSet; }
  template <typename EncryptionT = MsSmoothEncryptionSettings>
  void SetEncryption(EncryptionT&& value) {
    m_encryptionHasBeenSet = true;
    m_encryption = std::forward<EncryptionT>(value);
  }
  template <typename EncryptionT = MsSmoothEncryptionSettings>
  MsSmoothGroupSettings& WithEncryption(EncryptionT&& value) {
    SetEncryption(std::forward<EncryptionT>(value));
    return *this;
  }
 
 
  inline int GetFragmentLength() const { return m_fragmentLength; }
  inline bool FragmentLengthHasBeenSet() const { return m_fragmentLengthHasBeenSet; }
  inline void SetFragmentLength(int value) {
    m_fragmentLengthHasBeenSet = true;
    m_fragmentLength = value;
  }
  inline MsSmoothGroupSettings& WithFragmentLength(int value) {
    SetFragmentLength(value);
    return *this;
  }
 
 
  inline MsSmoothFragmentLengthControl GetFragmentLengthControl() const { return m_fragmentLengthControl; }
  inline bool FragmentLengthControlHasBeenSet() const { return m_fragmentLengthControlHasBeenSet; }
  inline void SetFragmentLengthControl(MsSmoothFragmentLengthControl value) {
    m_fragmentLengthControlHasBeenSet = true;
    m_fragmentLengthControl = value;
  }
  inline MsSmoothGroupSettings& WithFragmentLengthControl(MsSmoothFragmentLengthControl value) {
    SetFragmentLengthControl(value);
    return *this;
  }
 
 
  inline MsSmoothManifestEncoding GetManifestEncoding() const { return m_manifestEncoding; }
  inline bool ManifestEncodingHasBeenSet() const { return m_manifestEncodingHasBeenSet; }
  inline void SetManifestEncoding(MsSmoothManifestEncoding value) {
    m_manifestEncodingHasBeenSet = true;
    m_manifestEncoding = value;
  }
  inline MsSmoothGroupSettings& WithManifestEncoding(MsSmoothManifestEncoding value) {
    SetManifestEncoding(value);
    return *this;
  }
 private:
  Aws::Vector<MsSmoothAdditionalManifest> m_additionalManifests;
 
  MsSmoothAudioDeduplication m_audioDeduplication{MsSmoothAudioDeduplication::NOT_SET};
 
  Aws::String m_destination;
 
  DestinationSettings m_destinationSettings;
 
  MsSmoothEncryptionSettings m_encryption;
 
  int m_fragmentLength{0};
 
  MsSmoothFragmentLengthControl m_fragmentLengthControl{MsSmoothFragmentLengthControl::NOT_SET};
 
  MsSmoothManifestEncoding m_manifestEncoding{MsSmoothManifestEncoding::NOT_SET};
  bool m_additionalManifestsHasBeenSet = false;
  bool m_audioDeduplicationHasBeenSet = false;
  bool m_destinationHasBeenSet = false;
  bool m_destinationSettingsHasBeenSet = false;
  bool m_encryptionHasBeenSet = false;
  bool m_fragmentLengthHasBeenSet = false;
  bool m_fragmentLengthControlHasBeenSet = false;
  bool m_manifestEncodingHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws