ContainerSettings.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/CmfcSettings.h>
#include <aws/mediaconvert/model/ContainerType.h>
#include <aws/mediaconvert/model/F4vSettings.h>
#include <aws/mediaconvert/model/M2tsSettings.h>
#include <aws/mediaconvert/model/M3u8Settings.h>
#include <aws/mediaconvert/model/MovSettings.h>
#include <aws/mediaconvert/model/Mp4Settings.h>
#include <aws/mediaconvert/model/MpdSettings.h>
#include <aws/mediaconvert/model/MxfSettings.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class ContainerSettings {
 public:
  AWS_MEDIACONVERT_API ContainerSettings() = default;
  AWS_MEDIACONVERT_API ContainerSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API ContainerSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const CmfcSettings& GetCmfcSettings() const { return m_cmfcSettings; }
  inline bool CmfcSettingsHasBeenSet() const { return m_cmfcSettingsHasBeenSet; }
  template <typename CmfcSettingsT = CmfcSettings>
  void SetCmfcSettings(CmfcSettingsT&& value) {
    m_cmfcSettingsHasBeenSet = true;
    m_cmfcSettings = std::forward<CmfcSettingsT>(value);
  }
  template <typename CmfcSettingsT = CmfcSettings>
  ContainerSettings& WithCmfcSettings(CmfcSettingsT&& value) {
    SetCmfcSettings(std::forward<CmfcSettingsT>(value));
    return *this;
  }
 
 
  inline ContainerType GetContainer() const { return m_container; }
  inline bool ContainerHasBeenSet() const { return m_containerHasBeenSet; }
  inline void SetContainer(ContainerType value) {
    m_containerHasBeenSet = true;
    m_container = value;
  }
  inline ContainerSettings& WithContainer(ContainerType value) {
    SetContainer(value);
    return *this;
  }
 
 
  inline const F4vSettings& GetF4vSettings() const { return m_f4vSettings; }
  inline bool F4vSettingsHasBeenSet() const { return m_f4vSettingsHasBeenSet; }
  template <typename F4vSettingsT = F4vSettings>
  void SetF4vSettings(F4vSettingsT&& value) {
    m_f4vSettingsHasBeenSet = true;
    m_f4vSettings = std::forward<F4vSettingsT>(value);
  }
  template <typename F4vSettingsT = F4vSettings>
  ContainerSettings& WithF4vSettings(F4vSettingsT&& value) {
    SetF4vSettings(std::forward<F4vSettingsT>(value));
    return *this;
  }
 
 
  inline const M2tsSettings& GetM2tsSettings() const { return m_m2tsSettings; }
  inline bool M2tsSettingsHasBeenSet() const { return m_m2tsSettingsHasBeenSet; }
  template <typename M2tsSettingsT = M2tsSettings>
  void SetM2tsSettings(M2tsSettingsT&& value) {
    m_m2tsSettingsHasBeenSet = true;
    m_m2tsSettings = std::forward<M2tsSettingsT>(value);
  }
  template <typename M2tsSettingsT = M2tsSettings>
  ContainerSettings& WithM2tsSettings(M2tsSettingsT&& value) {
    SetM2tsSettings(std::forward<M2tsSettingsT>(value));
    return *this;
  }
 
 
  inline const M3u8Settings& GetM3u8Settings() const { return m_m3u8Settings; }
  inline bool M3u8SettingsHasBeenSet() const { return m_m3u8SettingsHasBeenSet; }
  template <typename M3u8SettingsT = M3u8Settings>
  void SetM3u8Settings(M3u8SettingsT&& value) {
    m_m3u8SettingsHasBeenSet = true;
    m_m3u8Settings = std::forward<M3u8SettingsT>(value);
  }
  template <typename M3u8SettingsT = M3u8Settings>
  ContainerSettings& WithM3u8Settings(M3u8SettingsT&& value) {
    SetM3u8Settings(std::forward<M3u8SettingsT>(value));
    return *this;
  }
 
 
  inline const MovSettings& GetMovSettings() const { return m_movSettings; }
  inline bool MovSettingsHasBeenSet() const { return m_movSettingsHasBeenSet; }
  template <typename MovSettingsT = MovSettings>
  void SetMovSettings(MovSettingsT&& value) {
    m_movSettingsHasBeenSet = true;
    m_movSettings = std::forward<MovSettingsT>(value);
  }
  template <typename MovSettingsT = MovSettings>
  ContainerSettings& WithMovSettings(MovSettingsT&& value) {
    SetMovSettings(std::forward<MovSettingsT>(value));
    return *this;
  }
 
 
  inline const Mp4Settings& GetMp4Settings() const { return m_mp4Settings; }
  inline bool Mp4SettingsHasBeenSet() const { return m_mp4SettingsHasBeenSet; }
  template <typename Mp4SettingsT = Mp4Settings>
  void SetMp4Settings(Mp4SettingsT&& value) {
    m_mp4SettingsHasBeenSet = true;
    m_mp4Settings = std::forward<Mp4SettingsT>(value);
  }
  template <typename Mp4SettingsT = Mp4Settings>
  ContainerSettings& WithMp4Settings(Mp4SettingsT&& value) {
    SetMp4Settings(std::forward<Mp4SettingsT>(value));
    return *this;
  }
 
 
  inline const MpdSettings& GetMpdSettings() const { return m_mpdSettings; }
  inline bool MpdSettingsHasBeenSet() const { return m_mpdSettingsHasBeenSet; }
  template <typename MpdSettingsT = MpdSettings>
  void SetMpdSettings(MpdSettingsT&& value) {
    m_mpdSettingsHasBeenSet = true;
    m_mpdSettings = std::forward<MpdSettingsT>(value);
  }
  template <typename MpdSettingsT = MpdSettings>
  ContainerSettings& WithMpdSettings(MpdSettingsT&& value) {
    SetMpdSettings(std::forward<MpdSettingsT>(value));
    return *this;
  }
 
 
  inline const MxfSettings& GetMxfSettings() const { return m_mxfSettings; }
  inline bool MxfSettingsHasBeenSet() const { return m_mxfSettingsHasBeenSet; }
  template <typename MxfSettingsT = MxfSettings>
  void SetMxfSettings(MxfSettingsT&& value) {
    m_mxfSettingsHasBeenSet = true;
    m_mxfSettings = std::forward<MxfSettingsT>(value);
  }
  template <typename MxfSettingsT = MxfSettings>
  ContainerSettings& WithMxfSettings(MxfSettingsT&& value) {
    SetMxfSettings(std::forward<MxfSettingsT>(value));
    return *this;
  }
 private:
  CmfcSettings m_cmfcSettings;
 
  ContainerType m_container{ContainerType::NOT_SET};
 
  F4vSettings m_f4vSettings;
 
  M2tsSettings m_m2tsSettings;
 
  M3u8Settings m_m3u8Settings;
 
  MovSettings m_movSettings;
 
  Mp4Settings m_mp4Settings;
 
  MpdSettings m_mpdSettings;
 
  MxfSettings m_mxfSettings;
  bool m_cmfcSettingsHasBeenSet = false;
  bool m_containerHasBeenSet = false;
  bool m_f4vSettingsHasBeenSet = false;
  bool m_m2tsSettingsHasBeenSet = false;
  bool m_m3u8SettingsHasBeenSet = false;
  bool m_movSettingsHasBeenSet = false;
  bool m_mp4SettingsHasBeenSet = false;
  bool m_mpdSettingsHasBeenSet = false;
  bool m_mxfSettingsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws