ServiceConnectService.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/model/TimeoutConfiguration.h>
#include <aws/ecs/model/ServiceConnectTlsConfiguration.h>
#include <aws/ecs/model/ServiceConnectClientAlias.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace ECS
{
namespace Model
{
 
  class ServiceConnectService
  {
  public:
    AWS_ECS_API ServiceConnectService() = default;
    AWS_ECS_API ServiceConnectService(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API ServiceConnectService& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetPortName() const { return m_portName; }
    inline bool PortNameHasBeenSet() const { return m_portNameHasBeenSet; }
    template<typename PortNameT = Aws::String>
    void SetPortName(PortNameT&& value) { m_portNameHasBeenSet = true; m_portName = std::forward<PortNameT>(value); }
    template<typename PortNameT = Aws::String>
    ServiceConnectService& WithPortName(PortNameT&& value) { SetPortName(std::forward<PortNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetDiscoveryName() const { return m_discoveryName; }
    inline bool DiscoveryNameHasBeenSet() const { return m_discoveryNameHasBeenSet; }
    template<typename DiscoveryNameT = Aws::String>
    void SetDiscoveryName(DiscoveryNameT&& value) { m_discoveryNameHasBeenSet = true; m_discoveryName = std::forward<DiscoveryNameT>(value); }
    template<typename DiscoveryNameT = Aws::String>
    ServiceConnectService& WithDiscoveryName(DiscoveryNameT&& value) { SetDiscoveryName(std::forward<DiscoveryNameT>(value)); return *this;}
 
 
    inline const Aws::Vector<ServiceConnectClientAlias>& GetClientAliases() const { return m_clientAliases; }
    inline bool ClientAliasesHasBeenSet() const { return m_clientAliasesHasBeenSet; }
    template<typename ClientAliasesT = Aws::Vector<ServiceConnectClientAlias>>
    void SetClientAliases(ClientAliasesT&& value) { m_clientAliasesHasBeenSet = true; m_clientAliases = std::forward<ClientAliasesT>(value); }
    template<typename ClientAliasesT = Aws::Vector<ServiceConnectClientAlias>>
    ServiceConnectService& WithClientAliases(ClientAliasesT&& value) { SetClientAliases(std::forward<ClientAliasesT>(value)); return *this;}
    template<typename ClientAliasesT = ServiceConnectClientAlias>
    ServiceConnectService& AddClientAliases(ClientAliasesT&& value) { m_clientAliasesHasBeenSet = true; m_clientAliases.emplace_back(std::forward<ClientAliasesT>(value)); return *this; }
 
 
    inline int GetIngressPortOverride() const { return m_ingressPortOverride; }
    inline bool IngressPortOverrideHasBeenSet() const { return m_ingressPortOverrideHasBeenSet; }
    inline void SetIngressPortOverride(int value) { m_ingressPortOverrideHasBeenSet = true; m_ingressPortOverride = value; }
    inline ServiceConnectService& WithIngressPortOverride(int value) { SetIngressPortOverride(value); return *this;}
 
 
    inline const TimeoutConfiguration& GetTimeout() const { return m_timeout; }
    inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }
    template<typename TimeoutT = TimeoutConfiguration>
    void SetTimeout(TimeoutT&& value) { m_timeoutHasBeenSet = true; m_timeout = std::forward<TimeoutT>(value); }
    template<typename TimeoutT = TimeoutConfiguration>
    ServiceConnectService& WithTimeout(TimeoutT&& value) { SetTimeout(std::forward<TimeoutT>(value)); return *this;}
 
 
    inline const ServiceConnectTlsConfiguration& GetTls() const { return m_tls; }
    inline bool TlsHasBeenSet() const { return m_tlsHasBeenSet; }
    template<typename TlsT = ServiceConnectTlsConfiguration>
    void SetTls(TlsT&& value) { m_tlsHasBeenSet = true; m_tls = std::forward<TlsT>(value); }
    template<typename TlsT = ServiceConnectTlsConfiguration>
    ServiceConnectService& WithTls(TlsT&& value) { SetTls(std::forward<TlsT>(value)); return *this;}
  private:
 
    Aws::String m_portName;
    bool m_portNameHasBeenSet = false;
 
    Aws::String m_discoveryName;
    bool m_discoveryNameHasBeenSet = false;
 
    Aws::Vector<ServiceConnectClientAlias> m_clientAliases;
    bool m_clientAliasesHasBeenSet = false;
 
    int m_ingressPortOverride{0};
    bool m_ingressPortOverrideHasBeenSet = false;
 
    TimeoutConfiguration m_timeout;
    bool m_timeoutHasBeenSet = false;
 
    ServiceConnectTlsConfiguration m_tls;
    bool m_tlsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ECS
} // namespace Aws