RedisSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/dms/DatabaseMigrationService_EXPORTS.h>
#include <aws/dms/model/RedisAuthTypeValue.h>
#include <aws/dms/model/SslSecurityProtocolValue.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DatabaseMigrationService {
namespace Model {
 
class RedisSettings {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API RedisSettings() = default;
  AWS_DATABASEMIGRATIONSERVICE_API RedisSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API RedisSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetServerName() const { return m_serverName; }
  inline bool ServerNameHasBeenSet() const { return m_serverNameHasBeenSet; }
  template <typename ServerNameT = Aws::String>
  void SetServerName(ServerNameT&& value) {
    m_serverNameHasBeenSet = true;
    m_serverName = std::forward<ServerNameT>(value);
  }
  template <typename ServerNameT = Aws::String>
  RedisSettings& WithServerName(ServerNameT&& value) {
    SetServerName(std::forward<ServerNameT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline RedisSettings& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline SslSecurityProtocolValue GetSslSecurityProtocol() const { return m_sslSecurityProtocol; }
  inline bool SslSecurityProtocolHasBeenSet() const { return m_sslSecurityProtocolHasBeenSet; }
  inline void SetSslSecurityProtocol(SslSecurityProtocolValue value) {
    m_sslSecurityProtocolHasBeenSet = true;
    m_sslSecurityProtocol = value;
  }
  inline RedisSettings& WithSslSecurityProtocol(SslSecurityProtocolValue value) {
    SetSslSecurityProtocol(value);
    return *this;
  }
 
 
  inline RedisAuthTypeValue GetAuthType() const { return m_authType; }
  inline bool AuthTypeHasBeenSet() const { return m_authTypeHasBeenSet; }
  inline void SetAuthType(RedisAuthTypeValue value) {
    m_authTypeHasBeenSet = true;
    m_authType = value;
  }
  inline RedisSettings& WithAuthType(RedisAuthTypeValue value) {
    SetAuthType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAuthUserName() const { return m_authUserName; }
  inline bool AuthUserNameHasBeenSet() const { return m_authUserNameHasBeenSet; }
  template <typename AuthUserNameT = Aws::String>
  void SetAuthUserName(AuthUserNameT&& value) {
    m_authUserNameHasBeenSet = true;
    m_authUserName = std::forward<AuthUserNameT>(value);
  }
  template <typename AuthUserNameT = Aws::String>
  RedisSettings& WithAuthUserName(AuthUserNameT&& value) {
    SetAuthUserName(std::forward<AuthUserNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAuthPassword() const { return m_authPassword; }
  inline bool AuthPasswordHasBeenSet() const { return m_authPasswordHasBeenSet; }
  template <typename AuthPasswordT = Aws::String>
  void SetAuthPassword(AuthPasswordT&& value) {
    m_authPasswordHasBeenSet = true;
    m_authPassword = std::forward<AuthPasswordT>(value);
  }
  template <typename AuthPasswordT = Aws::String>
  RedisSettings& WithAuthPassword(AuthPasswordT&& value) {
    SetAuthPassword(std::forward<AuthPasswordT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSslCaCertificateArn() const { return m_sslCaCertificateArn; }
  inline bool SslCaCertificateArnHasBeenSet() const { return m_sslCaCertificateArnHasBeenSet; }
  template <typename SslCaCertificateArnT = Aws::String>
  void SetSslCaCertificateArn(SslCaCertificateArnT&& value) {
    m_sslCaCertificateArnHasBeenSet = true;
    m_sslCaCertificateArn = std::forward<SslCaCertificateArnT>(value);
  }
  template <typename SslCaCertificateArnT = Aws::String>
  RedisSettings& WithSslCaCertificateArn(SslCaCertificateArnT&& value) {
    SetSslCaCertificateArn(std::forward<SslCaCertificateArnT>(value));
    return *this;
  }
 private:
  Aws::String m_serverName;
 
  int m_port{0};
 
  SslSecurityProtocolValue m_sslSecurityProtocol{SslSecurityProtocolValue::NOT_SET};
 
  RedisAuthTypeValue m_authType{RedisAuthTypeValue::NOT_SET};
 
  Aws::String m_authUserName;
 
  Aws::String m_authPassword;
 
  Aws::String m_sslCaCertificateArn;
  bool m_serverNameHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_sslSecurityProtocolHasBeenSet = false;
  bool m_authTypeHasBeenSet = false;
  bool m_authUserNameHasBeenSet = false;
  bool m_authPasswordHasBeenSet = false;
  bool m_sslCaCertificateArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws