JobSettings.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AvailBlanking.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/model/EsamSettings.h>
#include <aws/mediaconvert/model/ExtendedDataServices.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/TimecodeConfig.h>
#include <aws/mediaconvert/model/TimedMetadataInsertion.h>
#include <aws/mediaconvert/model/ColorConversion3DLUTSetting.h>
#include <aws/mediaconvert/model/Input.h>
#include <aws/mediaconvert/model/OutputGroup.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaConvert
{
namespace Model
{
 
  class JobSettings
  {
  public:
    AWS_MEDIACONVERT_API JobSettings() = default;
    AWS_MEDIACONVERT_API JobSettings(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIACONVERT_API JobSettings& 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 JobSettings& 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>
    JobSettings& 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>>
    JobSettings& WithColorConversion3DLUTSettings(ColorConversion3DLUTSettingsT&& value) { SetColorConversion3DLUTSettings(std::forward<ColorConversion3DLUTSettingsT>(value)); return *this;}
    template<typename ColorConversion3DLUTSettingsT = ColorConversion3DLUTSetting>
    JobSettings& 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>
    JobSettings& 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>
    JobSettings& 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 JobSettings& WithFollowSource(int value) { SetFollowSource(value); return *this;}
 
 
    inline const Aws::Vector<Input>& GetInputs() const { return m_inputs; }
    inline bool InputsHasBeenSet() const { return m_inputsHasBeenSet; }
    template<typename InputsT = Aws::Vector<Input>>
    void SetInputs(InputsT&& value) { m_inputsHasBeenSet = true; m_inputs = std::forward<InputsT>(value); }
    template<typename InputsT = Aws::Vector<Input>>
    JobSettings& WithInputs(InputsT&& value) { SetInputs(std::forward<InputsT>(value)); return *this;}
    template<typename InputsT = Input>
    JobSettings& 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>
    JobSettings& 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>
    JobSettings& 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>
    JobSettings& 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>
    JobSettings& 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>>
    JobSettings& WithOutputGroups(OutputGroupsT&& value) { SetOutputGroups(std::forward<OutputGroupsT>(value)); return *this;}
    template<typename OutputGroupsT = OutputGroup>
    JobSettings& 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>
    JobSettings& 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>
    JobSettings& WithTimedMetadataInsertion(TimedMetadataInsertionT&& value) { SetTimedMetadataInsertion(std::forward<TimedMetadataInsertionT>(value)); return *this;}
  private:
 
    int m_adAvailOffset{0};
    bool m_adAvailOffsetHasBeenSet = false;
 
    AvailBlanking m_availBlanking;
    bool m_availBlankingHasBeenSet = false;
 
    Aws::Vector<ColorConversion3DLUTSetting> m_colorConversion3DLUTSettings;
    bool m_colorConversion3DLUTSettingsHasBeenSet = false;
 
    EsamSettings m_esam;
    bool m_esamHasBeenSet = false;
 
    ExtendedDataServices m_extendedDataServices;
    bool m_extendedDataServicesHasBeenSet = false;
 
    int m_followSource{0};
    bool m_followSourceHasBeenSet = false;
 
    Aws::Vector<Input> m_inputs;
    bool m_inputsHasBeenSet = false;
 
    KantarWatermarkSettings m_kantarWatermark;
    bool m_kantarWatermarkHasBeenSet = false;
 
    MotionImageInserter m_motionImageInserter;
    bool m_motionImageInserterHasBeenSet = false;
 
    NielsenConfiguration m_nielsenConfiguration;
    bool m_nielsenConfigurationHasBeenSet = false;
 
    NielsenNonLinearWatermarkSettings m_nielsenNonLinearWatermark;
    bool m_nielsenNonLinearWatermarkHasBeenSet = false;
 
    Aws::Vector<OutputGroup> m_outputGroups;
    bool m_outputGroupsHasBeenSet = false;
 
    TimecodeConfig m_timecodeConfig;
    bool m_timecodeConfigHasBeenSet = false;
 
    TimedMetadataInsertion m_timedMetadataInsertion;
    bool m_timedMetadataInsertionHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws