MsSmoothGroupSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/InputLossActionForMsSmoothOut.h>
#include <aws/medialive/model/OutputLocationRef.h>
#include <aws/medialive/model/SmoothGroupAudioOnlyTimecodeControl.h>
#include <aws/medialive/model/SmoothGroupCertificateMode.h>
#include <aws/medialive/model/SmoothGroupEventIdMode.h>
#include <aws/medialive/model/SmoothGroupEventStopBehavior.h>
#include <aws/medialive/model/SmoothGroupSegmentationMode.h>
#include <aws/medialive/model/SmoothGroupSparseTrackType.h>
#include <aws/medialive/model/SmoothGroupStreamManifestBehavior.h>
#include <aws/medialive/model/SmoothGroupTimestampOffsetMode.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaLive {
namespace Model {
 
class MsSmoothGroupSettings {
 public:
  AWS_MEDIALIVE_API MsSmoothGroupSettings() = default;
  AWS_MEDIALIVE_API MsSmoothGroupSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API MsSmoothGroupSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAcquisitionPointId() const { return m_acquisitionPointId; }
  inline bool AcquisitionPointIdHasBeenSet() const { return m_acquisitionPointIdHasBeenSet; }
  template <typename AcquisitionPointIdT = Aws::String>
  void SetAcquisitionPointId(AcquisitionPointIdT&& value) {
    m_acquisitionPointIdHasBeenSet = true;
    m_acquisitionPointId = std::forward<AcquisitionPointIdT>(value);
  }
  template <typename AcquisitionPointIdT = Aws::String>
  MsSmoothGroupSettings& WithAcquisitionPointId(AcquisitionPointIdT&& value) {
    SetAcquisitionPointId(std::forward<AcquisitionPointIdT>(value));
    return *this;
  }
 
 
  inline SmoothGroupAudioOnlyTimecodeControl GetAudioOnlyTimecodeControl() const { return m_audioOnlyTimecodeControl; }
  inline bool AudioOnlyTimecodeControlHasBeenSet() const { return m_audioOnlyTimecodeControlHasBeenSet; }
  inline void SetAudioOnlyTimecodeControl(SmoothGroupAudioOnlyTimecodeControl value) {
    m_audioOnlyTimecodeControlHasBeenSet = true;
    m_audioOnlyTimecodeControl = value;
  }
  inline MsSmoothGroupSettings& WithAudioOnlyTimecodeControl(SmoothGroupAudioOnlyTimecodeControl value) {
    SetAudioOnlyTimecodeControl(value);
    return *this;
  }
 
 
  inline SmoothGroupCertificateMode GetCertificateMode() const { return m_certificateMode; }
  inline bool CertificateModeHasBeenSet() const { return m_certificateModeHasBeenSet; }
  inline void SetCertificateMode(SmoothGroupCertificateMode value) {
    m_certificateModeHasBeenSet = true;
    m_certificateMode = value;
  }
  inline MsSmoothGroupSettings& WithCertificateMode(SmoothGroupCertificateMode value) {
    SetCertificateMode(value);
    return *this;
  }
 
 
  inline int GetConnectionRetryInterval() const { return m_connectionRetryInterval; }
  inline bool ConnectionRetryIntervalHasBeenSet() const { return m_connectionRetryIntervalHasBeenSet; }
  inline void SetConnectionRetryInterval(int value) {
    m_connectionRetryIntervalHasBeenSet = true;
    m_connectionRetryInterval = value;
  }
  inline MsSmoothGroupSettings& WithConnectionRetryInterval(int value) {
    SetConnectionRetryInterval(value);
    return *this;
  }
 
 
  inline const OutputLocationRef& GetDestination() const { return m_destination; }
  inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
  template <typename DestinationT = OutputLocationRef>
  void SetDestination(DestinationT&& value) {
    m_destinationHasBeenSet = true;
    m_destination = std::forward<DestinationT>(value);
  }
  template <typename DestinationT = OutputLocationRef>
  MsSmoothGroupSettings& WithDestination(DestinationT&& value) {
    SetDestination(std::forward<DestinationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventId() const { return m_eventId; }
  inline bool EventIdHasBeenSet() const { return m_eventIdHasBeenSet; }
  template <typename EventIdT = Aws::String>
  void SetEventId(EventIdT&& value) {
    m_eventIdHasBeenSet = true;
    m_eventId = std::forward<EventIdT>(value);
  }
  template <typename EventIdT = Aws::String>
  MsSmoothGroupSettings& WithEventId(EventIdT&& value) {
    SetEventId(std::forward<EventIdT>(value));
    return *this;
  }
 
 
  inline SmoothGroupEventIdMode GetEventIdMode() const { return m_eventIdMode; }
  inline bool EventIdModeHasBeenSet() const { return m_eventIdModeHasBeenSet; }
  inline void SetEventIdMode(SmoothGroupEventIdMode value) {
    m_eventIdModeHasBeenSet = true;
    m_eventIdMode = value;
  }
  inline MsSmoothGroupSettings& WithEventIdMode(SmoothGroupEventIdMode value) {
    SetEventIdMode(value);
    return *this;
  }
 
 
  inline SmoothGroupEventStopBehavior GetEventStopBehavior() const { return m_eventStopBehavior; }
  inline bool EventStopBehaviorHasBeenSet() const { return m_eventStopBehaviorHasBeenSet; }
  inline void SetEventStopBehavior(SmoothGroupEventStopBehavior value) {
    m_eventStopBehaviorHasBeenSet = true;
    m_eventStopBehavior = value;
  }
  inline MsSmoothGroupSettings& WithEventStopBehavior(SmoothGroupEventStopBehavior value) {
    SetEventStopBehavior(value);
    return *this;
  }
 
 
  inline int GetFilecacheDuration() const { return m_filecacheDuration; }
  inline bool FilecacheDurationHasBeenSet() const { return m_filecacheDurationHasBeenSet; }
  inline void SetFilecacheDuration(int value) {
    m_filecacheDurationHasBeenSet = true;
    m_filecacheDuration = value;
  }
  inline MsSmoothGroupSettings& WithFilecacheDuration(int value) {
    SetFilecacheDuration(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 InputLossActionForMsSmoothOut GetInputLossAction() const { return m_inputLossAction; }
  inline bool InputLossActionHasBeenSet() const { return m_inputLossActionHasBeenSet; }
  inline void SetInputLossAction(InputLossActionForMsSmoothOut value) {
    m_inputLossActionHasBeenSet = true;
    m_inputLossAction = value;
  }
  inline MsSmoothGroupSettings& WithInputLossAction(InputLossActionForMsSmoothOut value) {
    SetInputLossAction(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 MsSmoothGroupSettings& WithNumRetries(int value) {
    SetNumRetries(value);
    return *this;
  }
 
 
  inline int GetRestartDelay() const { return m_restartDelay; }
  inline bool RestartDelayHasBeenSet() const { return m_restartDelayHasBeenSet; }
  inline void SetRestartDelay(int value) {
    m_restartDelayHasBeenSet = true;
    m_restartDelay = value;
  }
  inline MsSmoothGroupSettings& WithRestartDelay(int value) {
    SetRestartDelay(value);
    return *this;
  }
 
 
  inline SmoothGroupSegmentationMode GetSegmentationMode() const { return m_segmentationMode; }
  inline bool SegmentationModeHasBeenSet() const { return m_segmentationModeHasBeenSet; }
  inline void SetSegmentationMode(SmoothGroupSegmentationMode value) {
    m_segmentationModeHasBeenSet = true;
    m_segmentationMode = value;
  }
  inline MsSmoothGroupSettings& WithSegmentationMode(SmoothGroupSegmentationMode value) {
    SetSegmentationMode(value);
    return *this;
  }
 
 
  inline int GetSendDelayMs() const { return m_sendDelayMs; }
  inline bool SendDelayMsHasBeenSet() const { return m_sendDelayMsHasBeenSet; }
  inline void SetSendDelayMs(int value) {
    m_sendDelayMsHasBeenSet = true;
    m_sendDelayMs = value;
  }
  inline MsSmoothGroupSettings& WithSendDelayMs(int value) {
    SetSendDelayMs(value);
    return *this;
  }
 
 
  inline SmoothGroupSparseTrackType GetSparseTrackType() const { return m_sparseTrackType; }
  inline bool SparseTrackTypeHasBeenSet() const { return m_sparseTrackTypeHasBeenSet; }
  inline void SetSparseTrackType(SmoothGroupSparseTrackType value) {
    m_sparseTrackTypeHasBeenSet = true;
    m_sparseTrackType = value;
  }
  inline MsSmoothGroupSettings& WithSparseTrackType(SmoothGroupSparseTrackType value) {
    SetSparseTrackType(value);
    return *this;
  }
 
 
  inline SmoothGroupStreamManifestBehavior GetStreamManifestBehavior() const { return m_streamManifestBehavior; }
  inline bool StreamManifestBehaviorHasBeenSet() const { return m_streamManifestBehaviorHasBeenSet; }
  inline void SetStreamManifestBehavior(SmoothGroupStreamManifestBehavior value) {
    m_streamManifestBehaviorHasBeenSet = true;
    m_streamManifestBehavior = value;
  }
  inline MsSmoothGroupSettings& WithStreamManifestBehavior(SmoothGroupStreamManifestBehavior value) {
    SetStreamManifestBehavior(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTimestampOffset() const { return m_timestampOffset; }
  inline bool TimestampOffsetHasBeenSet() const { return m_timestampOffsetHasBeenSet; }
  template <typename TimestampOffsetT = Aws::String>
  void SetTimestampOffset(TimestampOffsetT&& value) {
    m_timestampOffsetHasBeenSet = true;
    m_timestampOffset = std::forward<TimestampOffsetT>(value);
  }
  template <typename TimestampOffsetT = Aws::String>
  MsSmoothGroupSettings& WithTimestampOffset(TimestampOffsetT&& value) {
    SetTimestampOffset(std::forward<TimestampOffsetT>(value));
    return *this;
  }
 
 
  inline SmoothGroupTimestampOffsetMode GetTimestampOffsetMode() const { return m_timestampOffsetMode; }
  inline bool TimestampOffsetModeHasBeenSet() const { return m_timestampOffsetModeHasBeenSet; }
  inline void SetTimestampOffsetMode(SmoothGroupTimestampOffsetMode value) {
    m_timestampOffsetModeHasBeenSet = true;
    m_timestampOffsetMode = value;
  }
  inline MsSmoothGroupSettings& WithTimestampOffsetMode(SmoothGroupTimestampOffsetMode value) {
    SetTimestampOffsetMode(value);
    return *this;
  }
 private:
  Aws::String m_acquisitionPointId;
 
  SmoothGroupAudioOnlyTimecodeControl m_audioOnlyTimecodeControl{SmoothGroupAudioOnlyTimecodeControl::NOT_SET};
 
  SmoothGroupCertificateMode m_certificateMode{SmoothGroupCertificateMode::NOT_SET};
 
  int m_connectionRetryInterval{0};
 
  OutputLocationRef m_destination;
 
  Aws::String m_eventId;
 
  SmoothGroupEventIdMode m_eventIdMode{SmoothGroupEventIdMode::NOT_SET};
 
  SmoothGroupEventStopBehavior m_eventStopBehavior{SmoothGroupEventStopBehavior::NOT_SET};
 
  int m_filecacheDuration{0};
 
  int m_fragmentLength{0};
 
  InputLossActionForMsSmoothOut m_inputLossAction{InputLossActionForMsSmoothOut::NOT_SET};
 
  int m_numRetries{0};
 
  int m_restartDelay{0};
 
  SmoothGroupSegmentationMode m_segmentationMode{SmoothGroupSegmentationMode::NOT_SET};
 
  int m_sendDelayMs{0};
 
  SmoothGroupSparseTrackType m_sparseTrackType{SmoothGroupSparseTrackType::NOT_SET};
 
  SmoothGroupStreamManifestBehavior m_streamManifestBehavior{SmoothGroupStreamManifestBehavior::NOT_SET};
 
  Aws::String m_timestampOffset;
 
  SmoothGroupTimestampOffsetMode m_timestampOffsetMode{SmoothGroupTimestampOffsetMode::NOT_SET};
  bool m_acquisitionPointIdHasBeenSet = false;
  bool m_audioOnlyTimecodeControlHasBeenSet = false;
  bool m_certificateModeHasBeenSet = false;
  bool m_connectionRetryIntervalHasBeenSet = false;
  bool m_destinationHasBeenSet = false;
  bool m_eventIdHasBeenSet = false;
  bool m_eventIdModeHasBeenSet = false;
  bool m_eventStopBehaviorHasBeenSet = false;
  bool m_filecacheDurationHasBeenSet = false;
  bool m_fragmentLengthHasBeenSet = false;
  bool m_inputLossActionHasBeenSet = false;
  bool m_numRetriesHasBeenSet = false;
  bool m_restartDelayHasBeenSet = false;
  bool m_segmentationModeHasBeenSet = false;
  bool m_sendDelayMsHasBeenSet = false;
  bool m_sparseTrackTypeHasBeenSet = false;
  bool m_streamManifestBehaviorHasBeenSet = false;
  bool m_timestampOffsetHasBeenSet = false;
  bool m_timestampOffsetModeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaLive
}  // namespace Aws