MsSmoothGroupSettings.h

 
#pragma once
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/medialive/model/SmoothGroupAudioOnlyTimecodeControl.h>
#include <aws/medialive/model/SmoothGroupCertificateMode.h>
#include <aws/medialive/model/OutputLocationRef.h>
#include <aws/medialive/model/SmoothGroupEventIdMode.h>
#include <aws/medialive/model/SmoothGroupEventStopBehavior.h>
#include <aws/medialive/model/InputLossActionForMsSmoothOut.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;
    bool m_acquisitionPointIdHasBeenSet = false;
 
    SmoothGroupAudioOnlyTimecodeControl m_audioOnlyTimecodeControl{SmoothGroupAudioOnlyTimecodeControl::NOT_SET};
    bool m_audioOnlyTimecodeControlHasBeenSet = false;
 
    SmoothGroupCertificateMode m_certificateMode{SmoothGroupCertificateMode::NOT_SET};
    bool m_certificateModeHasBeenSet = false;
 
    int m_connectionRetryInterval{0};
    bool m_connectionRetryIntervalHasBeenSet = false;
 
    OutputLocationRef m_destination;
    bool m_destinationHasBeenSet = false;
 
    Aws::String m_eventId;
    bool m_eventIdHasBeenSet = false;
 
    SmoothGroupEventIdMode m_eventIdMode{SmoothGroupEventIdMode::NOT_SET};
    bool m_eventIdModeHasBeenSet = false;
 
    SmoothGroupEventStopBehavior m_eventStopBehavior{SmoothGroupEventStopBehavior::NOT_SET};
    bool m_eventStopBehaviorHasBeenSet = false;
 
    int m_filecacheDuration{0};
    bool m_filecacheDurationHasBeenSet = false;
 
    int m_fragmentLength{0};
    bool m_fragmentLengthHasBeenSet = false;
 
    InputLossActionForMsSmoothOut m_inputLossAction{InputLossActionForMsSmoothOut::NOT_SET};
    bool m_inputLossActionHasBeenSet = false;
 
    int m_numRetries{0};
    bool m_numRetriesHasBeenSet = false;
 
    int m_restartDelay{0};
    bool m_restartDelayHasBeenSet = false;
 
    SmoothGroupSegmentationMode m_segmentationMode{SmoothGroupSegmentationMode::NOT_SET};
    bool m_segmentationModeHasBeenSet = false;
 
    int m_sendDelayMs{0};
    bool m_sendDelayMsHasBeenSet = false;
 
    SmoothGroupSparseTrackType m_sparseTrackType{SmoothGroupSparseTrackType::NOT_SET};
    bool m_sparseTrackTypeHasBeenSet = false;
 
    SmoothGroupStreamManifestBehavior m_streamManifestBehavior{SmoothGroupStreamManifestBehavior::NOT_SET};
    bool m_streamManifestBehaviorHasBeenSet = false;
 
    Aws::String m_timestampOffset;
    bool m_timestampOffsetHasBeenSet = false;
 
    SmoothGroupTimestampOffsetMode m_timestampOffsetMode{SmoothGroupTimestampOffsetMode::NOT_SET};
    bool m_timestampOffsetModeHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaLive
} // namespace Aws