JobTemplateSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AvailBlanking.h>
#include <aws/mediaconvert/model/ColorConversion3DLUTSetting.h>
#include <aws/mediaconvert/model/EsamSettings.h>
#include <aws/mediaconvert/model/ExtendedDataServices.h>
#include <aws/mediaconvert/model/InputTemplate.h>
#include <aws/mediaconvert/model/KantarWatermarkSettings.h>
#include <aws/mediaconvert/model/MotionImageInserter.h>
#include <aws/mediaconvert/model/NielsenConfiguration.h>
#include <aws/mediaconvert/model/NielsenNonLinearWatermarkSettings.h>
#include <aws/mediaconvert/model/OutputGroup.h>
#include <aws/mediaconvert/model/TimecodeConfig.h>
#include <aws/mediaconvert/model/TimedMetadataInsertion.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class JobTemplateSettings {
 public:
  AWS_MEDIACONVERT_API JobTemplateSettings() = default;
  AWS_MEDIACONVERT_API JobTemplateSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API JobTemplateSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetAdAvailOffset() const { return m_adAvailOffset; }
  inline bool AdAvailOffsetHasBeenSet() const { return m_adAvailOffsetHasBeenSet; }
  inline void SetAdAvailOffset(int value) {
    m_adAvailOffsetHasBeenSet = true;
    m_adAvailOffset = value;
  }
  inline JobTemplateSettings& WithAdAvailOffset(int value) {
    SetAdAvailOffset(value);
    return *this;
  }
 
 
  inline const AvailBlanking& GetAvailBlanking() const { return m_availBlanking; }
  inline bool AvailBlankingHasBeenSet() const { return m_availBlankingHasBeenSet; }
  template <typename AvailBlankingT = AvailBlanking>
  void SetAvailBlanking(AvailBlankingT&& value) {
    m_availBlankingHasBeenSet = true;
    m_availBlanking = std::forward<AvailBlankingT>(value);
  }
  template <typename AvailBlankingT = AvailBlanking>
  JobTemplateSettings& WithAvailBlanking(AvailBlankingT&& value) {
    SetAvailBlanking(std::forward<AvailBlankingT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ColorConversion3DLUTSetting>& GetColorConversion3DLUTSettings() const { return m_colorConversion3DLUTSettings; }
  inline bool ColorConversion3DLUTSettingsHasBeenSet() const { return m_colorConversion3DLUTSettingsHasBeenSet; }
  template <typename ColorConversion3DLUTSettingsT = Aws::Vector<ColorConversion3DLUTSetting>>
  void SetColorConversion3DLUTSettings(ColorConversion3DLUTSettingsT&& value) {
    m_colorConversion3DLUTSettingsHasBeenSet = true;
    m_colorConversion3DLUTSettings = std::forward<ColorConversion3DLUTSettingsT>(value);
  }
  template <typename ColorConversion3DLUTSettingsT = Aws::Vector<ColorConversion3DLUTSetting>>
  JobTemplateSettings& WithColorConversion3DLUTSettings(ColorConversion3DLUTSettingsT&& value) {
    SetColorConversion3DLUTSettings(std::forward<ColorConversion3DLUTSettingsT>(value));
    return *this;
  }
  template <typename ColorConversion3DLUTSettingsT = ColorConversion3DLUTSetting>
  JobTemplateSettings& AddColorConversion3DLUTSettings(ColorConversion3DLUTSettingsT&& value) {
    m_colorConversion3DLUTSettingsHasBeenSet = true;
    m_colorConversion3DLUTSettings.emplace_back(std::forward<ColorConversion3DLUTSettingsT>(value));
    return *this;
  }
 
 
  inline const EsamSettings& GetEsam() const { return m_esam; }
  inline bool EsamHasBeenSet() const { return m_esamHasBeenSet; }
  template <typename EsamT = EsamSettings>
  void SetEsam(EsamT&& value) {
    m_esamHasBeenSet = true;
    m_esam = std::forward<EsamT>(value);
  }
  template <typename EsamT = EsamSettings>
  JobTemplateSettings& WithEsam(EsamT&& value) {
    SetEsam(std::forward<EsamT>(value));
    return *this;
  }
 
 
  inline const ExtendedDataServices& GetExtendedDataServices() const { return m_extendedDataServices; }
  inline bool ExtendedDataServicesHasBeenSet() const { return m_extendedDataServicesHasBeenSet; }
  template <typename ExtendedDataServicesT = ExtendedDataServices>
  void SetExtendedDataServices(ExtendedDataServicesT&& value) {
    m_extendedDataServicesHasBeenSet = true;
    m_extendedDataServices = std::forward<ExtendedDataServicesT>(value);
  }
  template <typename ExtendedDataServicesT = ExtendedDataServices>
  JobTemplateSettings& WithExtendedDataServices(ExtendedDataServicesT&& value) {
    SetExtendedDataServices(std::forward<ExtendedDataServicesT>(value));
    return *this;
  }
 
 
  inline int GetFollowSource() const { return m_followSource; }
  inline bool FollowSourceHasBeenSet() const { return m_followSourceHasBeenSet; }
  inline void SetFollowSource(int value) {
    m_followSourceHasBeenSet = true;
    m_followSource = value;
  }
  inline JobTemplateSettings& WithFollowSource(int value) {
    SetFollowSource(value);
    return *this;
  }
 
 
  inline const Aws::Vector<InputTemplate>& GetInputs() const { return m_inputs; }
  inline bool InputsHasBeenSet() const { return m_inputsHasBeenSet; }
  template <typename InputsT = Aws::Vector<InputTemplate>>
  void SetInputs(InputsT&& value) {
    m_inputsHasBeenSet = true;
    m_inputs = std::forward<InputsT>(value);
  }
  template <typename InputsT = Aws::Vector<InputTemplate>>
  JobTemplateSettings& WithInputs(InputsT&& value) {
    SetInputs(std::forward<InputsT>(value));
    return *this;
  }
  template <typename InputsT = InputTemplate>
  JobTemplateSettings& AddInputs(InputsT&& value) {
    m_inputsHasBeenSet = true;
    m_inputs.emplace_back(std::forward<InputsT>(value));
    return *this;
  }
 
 
  inline const KantarWatermarkSettings& GetKantarWatermark() const { return m_kantarWatermark; }
  inline bool KantarWatermarkHasBeenSet() const { return m_kantarWatermarkHasBeenSet; }
  template <typename KantarWatermarkT = KantarWatermarkSettings>
  void SetKantarWatermark(KantarWatermarkT&& value) {
    m_kantarWatermarkHasBeenSet = true;
    m_kantarWatermark = std::forward<KantarWatermarkT>(value);
  }
  template <typename KantarWatermarkT = KantarWatermarkSettings>
  JobTemplateSettings& WithKantarWatermark(KantarWatermarkT&& value) {
    SetKantarWatermark(std::forward<KantarWatermarkT>(value));
    return *this;
  }
 
 
  inline const MotionImageInserter& GetMotionImageInserter() const { return m_motionImageInserter; }
  inline bool MotionImageInserterHasBeenSet() const { return m_motionImageInserterHasBeenSet; }
  template <typename MotionImageInserterT = MotionImageInserter>
  void SetMotionImageInserter(MotionImageInserterT&& value) {
    m_motionImageInserterHasBeenSet = true;
    m_motionImageInserter = std::forward<MotionImageInserterT>(value);
  }
  template <typename MotionImageInserterT = MotionImageInserter>
  JobTemplateSettings& WithMotionImageInserter(MotionImageInserterT&& value) {
    SetMotionImageInserter(std::forward<MotionImageInserterT>(value));
    return *this;
  }
 
 
  inline const NielsenConfiguration& GetNielsenConfiguration() const { return m_nielsenConfiguration; }
  inline bool NielsenConfigurationHasBeenSet() const { return m_nielsenConfigurationHasBeenSet; }
  template <typename NielsenConfigurationT = NielsenConfiguration>
  void SetNielsenConfiguration(NielsenConfigurationT&& value) {
    m_nielsenConfigurationHasBeenSet = true;
    m_nielsenConfiguration = std::forward<NielsenConfigurationT>(value);
  }
  template <typename NielsenConfigurationT = NielsenConfiguration>
  JobTemplateSettings& WithNielsenConfiguration(NielsenConfigurationT&& value) {
    SetNielsenConfiguration(std::forward<NielsenConfigurationT>(value));
    return *this;
  }
 
 
  inline const NielsenNonLinearWatermarkSettings& GetNielsenNonLinearWatermark() const { return m_nielsenNonLinearWatermark; }
  inline bool NielsenNonLinearWatermarkHasBeenSet() const { return m_nielsenNonLinearWatermarkHasBeenSet; }
  template <typename NielsenNonLinearWatermarkT = NielsenNonLinearWatermarkSettings>
  void SetNielsenNonLinearWatermark(NielsenNonLinearWatermarkT&& value) {
    m_nielsenNonLinearWatermarkHasBeenSet = true;
    m_nielsenNonLinearWatermark = std::forward<NielsenNonLinearWatermarkT>(value);
  }
  template <typename NielsenNonLinearWatermarkT = NielsenNonLinearWatermarkSettings>
  JobTemplateSettings& WithNielsenNonLinearWatermark(NielsenNonLinearWatermarkT&& value) {
    SetNielsenNonLinearWatermark(std::forward<NielsenNonLinearWatermarkT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<OutputGroup>& GetOutputGroups() const { return m_outputGroups; }
  inline bool OutputGroupsHasBeenSet() const { return m_outputGroupsHasBeenSet; }
  template <typename OutputGroupsT = Aws::Vector<OutputGroup>>
  void SetOutputGroups(OutputGroupsT&& value) {
    m_outputGroupsHasBeenSet = true;
    m_outputGroups = std::forward<OutputGroupsT>(value);
  }
  template <typename OutputGroupsT = Aws::Vector<OutputGroup>>
  JobTemplateSettings& WithOutputGroups(OutputGroupsT&& value) {
    SetOutputGroups(std::forward<OutputGroupsT>(value));
    return *this;
  }
  template <typename OutputGroupsT = OutputGroup>
  JobTemplateSettings& AddOutputGroups(OutputGroupsT&& value) {
    m_outputGroupsHasBeenSet = true;
    m_outputGroups.emplace_back(std::forward<OutputGroupsT>(value));
    return *this;
  }
 
 
  inline const TimecodeConfig& GetTimecodeConfig() const { return m_timecodeConfig; }
  inline bool TimecodeConfigHasBeenSet() const { return m_timecodeConfigHasBeenSet; }
  template <typename TimecodeConfigT = TimecodeConfig>
  void SetTimecodeConfig(TimecodeConfigT&& value) {
    m_timecodeConfigHasBeenSet = true;
    m_timecodeConfig = std::forward<TimecodeConfigT>(value);
  }
  template <typename TimecodeConfigT = TimecodeConfig>
  JobTemplateSettings& WithTimecodeConfig(TimecodeConfigT&& value) {
    SetTimecodeConfig(std::forward<TimecodeConfigT>(value));
    return *this;
  }
 
 
  inline const TimedMetadataInsertion& GetTimedMetadataInsertion() const { return m_timedMetadataInsertion; }
  inline bool TimedMetadataInsertionHasBeenSet() const { return m_timedMetadataInsertionHasBeenSet; }
  template <typename TimedMetadataInsertionT = TimedMetadataInsertion>
  void SetTimedMetadataInsertion(TimedMetadataInsertionT&& value) {
    m_timedMetadataInsertionHasBeenSet = true;
    m_timedMetadataInsertion = std::forward<TimedMetadataInsertionT>(value);
  }
  template <typename TimedMetadataInsertionT = TimedMetadataInsertion>
  JobTemplateSettings& WithTimedMetadataInsertion(TimedMetadataInsertionT&& value) {
    SetTimedMetadataInsertion(std::forward<TimedMetadataInsertionT>(value));
    return *this;
  }
 private:
  int m_adAvailOffset{0};
 
  AvailBlanking m_availBlanking;
 
  Aws::Vector<ColorConversion3DLUTSetting> m_colorConversion3DLUTSettings;
 
  EsamSettings m_esam;
 
  ExtendedDataServices m_extendedDataServices;
 
  int m_followSource{0};
 
  Aws::Vector<InputTemplate> m_inputs;
 
  KantarWatermarkSettings m_kantarWatermark;
 
  MotionImageInserter m_motionImageInserter;
 
  NielsenConfiguration m_nielsenConfiguration;
 
  NielsenNonLinearWatermarkSettings m_nielsenNonLinearWatermark;
 
  Aws::Vector<OutputGroup> m_outputGroups;
 
  TimecodeConfig m_timecodeConfig;
 
  TimedMetadataInsertion m_timedMetadataInsertion;
  bool m_adAvailOffsetHasBeenSet = false;
  bool m_availBlankingHasBeenSet = false;
  bool m_colorConversion3DLUTSettingsHasBeenSet = false;
  bool m_esamHasBeenSet = false;
  bool m_extendedDataServicesHasBeenSet = false;
  bool m_followSourceHasBeenSet = false;
  bool m_inputsHasBeenSet = false;
  bool m_kantarWatermarkHasBeenSet = false;
  bool m_motionImageInserterHasBeenSet = false;
  bool m_nielsenConfigurationHasBeenSet = false;
  bool m_nielsenNonLinearWatermarkHasBeenSet = false;
  bool m_outputGroupsHasBeenSet = false;
  bool m_timecodeConfigHasBeenSet = false;
  bool m_timedMetadataInsertionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws