SrtCallerSource.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/SrtCallerDecryption.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaLive {
namespace Model {
 
class SrtCallerSource {
 public:
  AWS_MEDIALIVE_API SrtCallerSource() = default;
  AWS_MEDIALIVE_API SrtCallerSource(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API SrtCallerSource& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const SrtCallerDecryption& GetDecryption() const { return m_decryption; }
  inline bool DecryptionHasBeenSet() const { return m_decryptionHasBeenSet; }
  template <typename DecryptionT = SrtCallerDecryption>
  void SetDecryption(DecryptionT&& value) {
    m_decryptionHasBeenSet = true;
    m_decryption = std::forward<DecryptionT>(value);
  }
  template <typename DecryptionT = SrtCallerDecryption>
  SrtCallerSource& WithDecryption(DecryptionT&& value) {
    SetDecryption(std::forward<DecryptionT>(value));
    return *this;
  }
 
 
  inline int GetMinimumLatency() const { return m_minimumLatency; }
  inline bool MinimumLatencyHasBeenSet() const { return m_minimumLatencyHasBeenSet; }
  inline void SetMinimumLatency(int value) {
    m_minimumLatencyHasBeenSet = true;
    m_minimumLatency = value;
  }
  inline SrtCallerSource& WithMinimumLatency(int value) {
    SetMinimumLatency(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSrtListenerAddress() const { return m_srtListenerAddress; }
  inline bool SrtListenerAddressHasBeenSet() const { return m_srtListenerAddressHasBeenSet; }
  template <typename SrtListenerAddressT = Aws::String>
  void SetSrtListenerAddress(SrtListenerAddressT&& value) {
    m_srtListenerAddressHasBeenSet = true;
    m_srtListenerAddress = std::forward<SrtListenerAddressT>(value);
  }
  template <typename SrtListenerAddressT = Aws::String>
  SrtCallerSource& WithSrtListenerAddress(SrtListenerAddressT&& value) {
    SetSrtListenerAddress(std::forward<SrtListenerAddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSrtListenerPort() const { return m_srtListenerPort; }
  inline bool SrtListenerPortHasBeenSet() const { return m_srtListenerPortHasBeenSet; }
  template <typename SrtListenerPortT = Aws::String>
  void SetSrtListenerPort(SrtListenerPortT&& value) {
    m_srtListenerPortHasBeenSet = true;
    m_srtListenerPort = std::forward<SrtListenerPortT>(value);
  }
  template <typename SrtListenerPortT = Aws::String>
  SrtCallerSource& WithSrtListenerPort(SrtListenerPortT&& value) {
    SetSrtListenerPort(std::forward<SrtListenerPortT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStreamId() const { return m_streamId; }
  inline bool StreamIdHasBeenSet() const { return m_streamIdHasBeenSet; }
  template <typename StreamIdT = Aws::String>
  void SetStreamId(StreamIdT&& value) {
    m_streamIdHasBeenSet = true;
    m_streamId = std::forward<StreamIdT>(value);
  }
  template <typename StreamIdT = Aws::String>
  SrtCallerSource& WithStreamId(StreamIdT&& value) {
    SetStreamId(std::forward<StreamIdT>(value));
    return *this;
  }
 private:
  SrtCallerDecryption m_decryption;
 
  int m_minimumLatency{0};
 
  Aws::String m_srtListenerAddress;
 
  Aws::String m_srtListenerPort;
 
  Aws::String m_streamId;
  bool m_decryptionHasBeenSet = false;
  bool m_minimumLatencyHasBeenSet = false;
  bool m_srtListenerAddressHasBeenSet = false;
  bool m_srtListenerPortHasBeenSet = false;
  bool m_streamIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaLive
}  // namespace Aws