VideoOverlayInput.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AudioSelector.h>
#include <aws/mediaconvert/model/InputTimecodeSource.h>
#include <aws/mediaconvert/model/VideoOverlayInputClipping.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class VideoOverlayInput {
 public:
  AWS_MEDIACONVERT_API VideoOverlayInput() = default;
  AWS_MEDIACONVERT_API VideoOverlayInput(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API VideoOverlayInput& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Map<Aws::String, AudioSelector>& GetAudioSelectors() const { return m_audioSelectors; }
  inline bool AudioSelectorsHasBeenSet() const { return m_audioSelectorsHasBeenSet; }
  template <typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
  void SetAudioSelectors(AudioSelectorsT&& value) {
    m_audioSelectorsHasBeenSet = true;
    m_audioSelectors = std::forward<AudioSelectorsT>(value);
  }
  template <typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
  VideoOverlayInput& WithAudioSelectors(AudioSelectorsT&& value) {
    SetAudioSelectors(std::forward<AudioSelectorsT>(value));
    return *this;
  }
  template <typename AudioSelectorsKeyT = Aws::String, typename AudioSelectorsValueT = AudioSelector>
  VideoOverlayInput& AddAudioSelectors(AudioSelectorsKeyT&& key, AudioSelectorsValueT&& value) {
    m_audioSelectorsHasBeenSet = true;
    m_audioSelectors.emplace(std::forward<AudioSelectorsKeyT>(key), std::forward<AudioSelectorsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFileInput() const { return m_fileInput; }
  inline bool FileInputHasBeenSet() const { return m_fileInputHasBeenSet; }
  template <typename FileInputT = Aws::String>
  void SetFileInput(FileInputT&& value) {
    m_fileInputHasBeenSet = true;
    m_fileInput = std::forward<FileInputT>(value);
  }
  template <typename FileInputT = Aws::String>
  VideoOverlayInput& WithFileInput(FileInputT&& value) {
    SetFileInput(std::forward<FileInputT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VideoOverlayInputClipping>& GetInputClippings() const { return m_inputClippings; }
  inline bool InputClippingsHasBeenSet() const { return m_inputClippingsHasBeenSet; }
  template <typename InputClippingsT = Aws::Vector<VideoOverlayInputClipping>>
  void SetInputClippings(InputClippingsT&& value) {
    m_inputClippingsHasBeenSet = true;
    m_inputClippings = std::forward<InputClippingsT>(value);
  }
  template <typename InputClippingsT = Aws::Vector<VideoOverlayInputClipping>>
  VideoOverlayInput& WithInputClippings(InputClippingsT&& value) {
    SetInputClippings(std::forward<InputClippingsT>(value));
    return *this;
  }
  template <typename InputClippingsT = VideoOverlayInputClipping>
  VideoOverlayInput& AddInputClippings(InputClippingsT&& value) {
    m_inputClippingsHasBeenSet = true;
    m_inputClippings.emplace_back(std::forward<InputClippingsT>(value));
    return *this;
  }
 
 
  inline InputTimecodeSource GetTimecodeSource() const { return m_timecodeSource; }
  inline bool TimecodeSourceHasBeenSet() const { return m_timecodeSourceHasBeenSet; }
  inline void SetTimecodeSource(InputTimecodeSource value) {
    m_timecodeSourceHasBeenSet = true;
    m_timecodeSource = value;
  }
  inline VideoOverlayInput& WithTimecodeSource(InputTimecodeSource value) {
    SetTimecodeSource(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTimecodeStart() const { return m_timecodeStart; }
  inline bool TimecodeStartHasBeenSet() const { return m_timecodeStartHasBeenSet; }
  template <typename TimecodeStartT = Aws::String>
  void SetTimecodeStart(TimecodeStartT&& value) {
    m_timecodeStartHasBeenSet = true;
    m_timecodeStart = std::forward<TimecodeStartT>(value);
  }
  template <typename TimecodeStartT = Aws::String>
  VideoOverlayInput& WithTimecodeStart(TimecodeStartT&& value) {
    SetTimecodeStart(std::forward<TimecodeStartT>(value));
    return *this;
  }
 private:
  Aws::Map<Aws::String, AudioSelector> m_audioSelectors;
 
  Aws::String m_fileInput;
 
  Aws::Vector<VideoOverlayInputClipping> m_inputClippings;
 
  InputTimecodeSource m_timecodeSource{InputTimecodeSource::NOT_SET};
 
  Aws::String m_timecodeStart;
  bool m_audioSelectorsHasBeenSet = false;
  bool m_fileInputHasBeenSet = false;
  bool m_inputClippingsHasBeenSet = false;
  bool m_timecodeSourceHasBeenSet = false;
  bool m_timecodeStartHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws