PipelineDetail.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/ChannelEngineVersionResponse.h>
#include <aws/medialive/model/MediaConnectRouterOutputConnection.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaLive {
namespace Model {
 
class PipelineDetail {
 public:
  AWS_MEDIALIVE_API PipelineDetail() = default;
  AWS_MEDIALIVE_API PipelineDetail(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API PipelineDetail& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetActiveInputAttachmentName() const { return m_activeInputAttachmentName; }
  inline bool ActiveInputAttachmentNameHasBeenSet() const { return m_activeInputAttachmentNameHasBeenSet; }
  template <typename ActiveInputAttachmentNameT = Aws::String>
  void SetActiveInputAttachmentName(ActiveInputAttachmentNameT&& value) {
    m_activeInputAttachmentNameHasBeenSet = true;
    m_activeInputAttachmentName = std::forward<ActiveInputAttachmentNameT>(value);
  }
  template <typename ActiveInputAttachmentNameT = Aws::String>
  PipelineDetail& WithActiveInputAttachmentName(ActiveInputAttachmentNameT&& value) {
    SetActiveInputAttachmentName(std::forward<ActiveInputAttachmentNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetActiveInputSwitchActionName() const { return m_activeInputSwitchActionName; }
  inline bool ActiveInputSwitchActionNameHasBeenSet() const { return m_activeInputSwitchActionNameHasBeenSet; }
  template <typename ActiveInputSwitchActionNameT = Aws::String>
  void SetActiveInputSwitchActionName(ActiveInputSwitchActionNameT&& value) {
    m_activeInputSwitchActionNameHasBeenSet = true;
    m_activeInputSwitchActionName = std::forward<ActiveInputSwitchActionNameT>(value);
  }
  template <typename ActiveInputSwitchActionNameT = Aws::String>
  PipelineDetail& WithActiveInputSwitchActionName(ActiveInputSwitchActionNameT&& value) {
    SetActiveInputSwitchActionName(std::forward<ActiveInputSwitchActionNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetActiveMotionGraphicsActionName() const { return m_activeMotionGraphicsActionName; }
  inline bool ActiveMotionGraphicsActionNameHasBeenSet() const { return m_activeMotionGraphicsActionNameHasBeenSet; }
  template <typename ActiveMotionGraphicsActionNameT = Aws::String>
  void SetActiveMotionGraphicsActionName(ActiveMotionGraphicsActionNameT&& value) {
    m_activeMotionGraphicsActionNameHasBeenSet = true;
    m_activeMotionGraphicsActionName = std::forward<ActiveMotionGraphicsActionNameT>(value);
  }
  template <typename ActiveMotionGraphicsActionNameT = Aws::String>
  PipelineDetail& WithActiveMotionGraphicsActionName(ActiveMotionGraphicsActionNameT&& value) {
    SetActiveMotionGraphicsActionName(std::forward<ActiveMotionGraphicsActionNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetActiveMotionGraphicsUri() const { return m_activeMotionGraphicsUri; }
  inline bool ActiveMotionGraphicsUriHasBeenSet() const { return m_activeMotionGraphicsUriHasBeenSet; }
  template <typename ActiveMotionGraphicsUriT = Aws::String>
  void SetActiveMotionGraphicsUri(ActiveMotionGraphicsUriT&& value) {
    m_activeMotionGraphicsUriHasBeenSet = true;
    m_activeMotionGraphicsUri = std::forward<ActiveMotionGraphicsUriT>(value);
  }
  template <typename ActiveMotionGraphicsUriT = Aws::String>
  PipelineDetail& WithActiveMotionGraphicsUri(ActiveMotionGraphicsUriT&& value) {
    SetActiveMotionGraphicsUri(std::forward<ActiveMotionGraphicsUriT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPipelineId() const { return m_pipelineId; }
  inline bool PipelineIdHasBeenSet() const { return m_pipelineIdHasBeenSet; }
  template <typename PipelineIdT = Aws::String>
  void SetPipelineId(PipelineIdT&& value) {
    m_pipelineIdHasBeenSet = true;
    m_pipelineId = std::forward<PipelineIdT>(value);
  }
  template <typename PipelineIdT = Aws::String>
  PipelineDetail& WithPipelineId(PipelineIdT&& value) {
    SetPipelineId(std::forward<PipelineIdT>(value));
    return *this;
  }
 
 
  inline const ChannelEngineVersionResponse& GetChannelEngineVersion() const { return m_channelEngineVersion; }
  inline bool ChannelEngineVersionHasBeenSet() const { return m_channelEngineVersionHasBeenSet; }
  template <typename ChannelEngineVersionT = ChannelEngineVersionResponse>
  void SetChannelEngineVersion(ChannelEngineVersionT&& value) {
    m_channelEngineVersionHasBeenSet = true;
    m_channelEngineVersion = std::forward<ChannelEngineVersionT>(value);
  }
  template <typename ChannelEngineVersionT = ChannelEngineVersionResponse>
  PipelineDetail& WithChannelEngineVersion(ChannelEngineVersionT&& value) {
    SetChannelEngineVersion(std::forward<ChannelEngineVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, MediaConnectRouterOutputConnection>& GetMediaConnectRouterOutputConnectionMap() const {
    return m_mediaConnectRouterOutputConnectionMap;
  }
  inline bool MediaConnectRouterOutputConnectionMapHasBeenSet() const { return m_mediaConnectRouterOutputConnectionMapHasBeenSet; }
  template <typename MediaConnectRouterOutputConnectionMapT = Aws::Map<Aws::String, MediaConnectRouterOutputConnection>>
  void SetMediaConnectRouterOutputConnectionMap(MediaConnectRouterOutputConnectionMapT&& value) {
    m_mediaConnectRouterOutputConnectionMapHasBeenSet = true;
    m_mediaConnectRouterOutputConnectionMap = std::forward<MediaConnectRouterOutputConnectionMapT>(value);
  }
  template <typename MediaConnectRouterOutputConnectionMapT = Aws::Map<Aws::String, MediaConnectRouterOutputConnection>>
  PipelineDetail& WithMediaConnectRouterOutputConnectionMap(MediaConnectRouterOutputConnectionMapT&& value) {
    SetMediaConnectRouterOutputConnectionMap(std::forward<MediaConnectRouterOutputConnectionMapT>(value));
    return *this;
  }
  template <typename MediaConnectRouterOutputConnectionMapKeyT = Aws::String,
            typename MediaConnectRouterOutputConnectionMapValueT = MediaConnectRouterOutputConnection>
  PipelineDetail& AddMediaConnectRouterOutputConnectionMap(MediaConnectRouterOutputConnectionMapKeyT&& key,
                                                           MediaConnectRouterOutputConnectionMapValueT&& value) {
    m_mediaConnectRouterOutputConnectionMapHasBeenSet = true;
    m_mediaConnectRouterOutputConnectionMap.emplace(std::forward<MediaConnectRouterOutputConnectionMapKeyT>(key),
                                                    std::forward<MediaConnectRouterOutputConnectionMapValueT>(value));
    return *this;
  }
 private:
  Aws::String m_activeInputAttachmentName;
 
  Aws::String m_activeInputSwitchActionName;
 
  Aws::String m_activeMotionGraphicsActionName;
 
  Aws::String m_activeMotionGraphicsUri;
 
  Aws::String m_pipelineId;
 
  ChannelEngineVersionResponse m_channelEngineVersion;
 
  Aws::Map<Aws::String, MediaConnectRouterOutputConnection> m_mediaConnectRouterOutputConnectionMap;
  bool m_activeInputAttachmentNameHasBeenSet = false;
  bool m_activeInputSwitchActionNameHasBeenSet = false;
  bool m_activeMotionGraphicsActionNameHasBeenSet = false;
  bool m_activeMotionGraphicsUriHasBeenSet = false;
  bool m_pipelineIdHasBeenSet = false;
  bool m_channelEngineVersionHasBeenSet = false;
  bool m_mediaConnectRouterOutputConnectionMapHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaLive
}  // namespace Aws