RadiusSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ds/DirectoryService_EXPORTS.h>
#include <aws/ds/model/RadiusAuthenticationProtocol.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DirectoryService {
namespace Model {
 
class RadiusSettings {
 public:
  AWS_DIRECTORYSERVICE_API RadiusSettings() = default;
  AWS_DIRECTORYSERVICE_API RadiusSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_DIRECTORYSERVICE_API RadiusSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DIRECTORYSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetRadiusServers() const { return m_radiusServers; }
  inline bool RadiusServersHasBeenSet() const { return m_radiusServersHasBeenSet; }
  template <typename RadiusServersT = Aws::Vector<Aws::String>>
  void SetRadiusServers(RadiusServersT&& value) {
    m_radiusServersHasBeenSet = true;
    m_radiusServers = std::forward<RadiusServersT>(value);
  }
  template <typename RadiusServersT = Aws::Vector<Aws::String>>
  RadiusSettings& WithRadiusServers(RadiusServersT&& value) {
    SetRadiusServers(std::forward<RadiusServersT>(value));
    return *this;
  }
  template <typename RadiusServersT = Aws::String>
  RadiusSettings& AddRadiusServers(RadiusServersT&& value) {
    m_radiusServersHasBeenSet = true;
    m_radiusServers.emplace_back(std::forward<RadiusServersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetRadiusServersIpv6() const { return m_radiusServersIpv6; }
  inline bool RadiusServersIpv6HasBeenSet() const { return m_radiusServersIpv6HasBeenSet; }
  template <typename RadiusServersIpv6T = Aws::Vector<Aws::String>>
  void SetRadiusServersIpv6(RadiusServersIpv6T&& value) {
    m_radiusServersIpv6HasBeenSet = true;
    m_radiusServersIpv6 = std::forward<RadiusServersIpv6T>(value);
  }
  template <typename RadiusServersIpv6T = Aws::Vector<Aws::String>>
  RadiusSettings& WithRadiusServersIpv6(RadiusServersIpv6T&& value) {
    SetRadiusServersIpv6(std::forward<RadiusServersIpv6T>(value));
    return *this;
  }
  template <typename RadiusServersIpv6T = Aws::String>
  RadiusSettings& AddRadiusServersIpv6(RadiusServersIpv6T&& value) {
    m_radiusServersIpv6HasBeenSet = true;
    m_radiusServersIpv6.emplace_back(std::forward<RadiusServersIpv6T>(value));
    return *this;
  }
 
 
  inline int GetRadiusPort() const { return m_radiusPort; }
  inline bool RadiusPortHasBeenSet() const { return m_radiusPortHasBeenSet; }
  inline void SetRadiusPort(int value) {
    m_radiusPortHasBeenSet = true;
    m_radiusPort = value;
  }
  inline RadiusSettings& WithRadiusPort(int value) {
    SetRadiusPort(value);
    return *this;
  }
 
 
  inline int GetRadiusTimeout() const { return m_radiusTimeout; }
  inline bool RadiusTimeoutHasBeenSet() const { return m_radiusTimeoutHasBeenSet; }
  inline void SetRadiusTimeout(int value) {
    m_radiusTimeoutHasBeenSet = true;
    m_radiusTimeout = value;
  }
  inline RadiusSettings& WithRadiusTimeout(int value) {
    SetRadiusTimeout(value);
    return *this;
  }
 
 
  inline int GetRadiusRetries() const { return m_radiusRetries; }
  inline bool RadiusRetriesHasBeenSet() const { return m_radiusRetriesHasBeenSet; }
  inline void SetRadiusRetries(int value) {
    m_radiusRetriesHasBeenSet = true;
    m_radiusRetries = value;
  }
  inline RadiusSettings& WithRadiusRetries(int value) {
    SetRadiusRetries(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSharedSecret() const { return m_sharedSecret; }
  inline bool SharedSecretHasBeenSet() const { return m_sharedSecretHasBeenSet; }
  template <typename SharedSecretT = Aws::String>
  void SetSharedSecret(SharedSecretT&& value) {
    m_sharedSecretHasBeenSet = true;
    m_sharedSecret = std::forward<SharedSecretT>(value);
  }
  template <typename SharedSecretT = Aws::String>
  RadiusSettings& WithSharedSecret(SharedSecretT&& value) {
    SetSharedSecret(std::forward<SharedSecretT>(value));
    return *this;
  }
 
 
  inline RadiusAuthenticationProtocol GetAuthenticationProtocol() const { return m_authenticationProtocol; }
  inline bool AuthenticationProtocolHasBeenSet() const { return m_authenticationProtocolHasBeenSet; }
  inline void SetAuthenticationProtocol(RadiusAuthenticationProtocol value) {
    m_authenticationProtocolHasBeenSet = true;
    m_authenticationProtocol = value;
  }
  inline RadiusSettings& WithAuthenticationProtocol(RadiusAuthenticationProtocol value) {
    SetAuthenticationProtocol(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDisplayLabel() const { return m_displayLabel; }
  inline bool DisplayLabelHasBeenSet() const { return m_displayLabelHasBeenSet; }
  template <typename DisplayLabelT = Aws::String>
  void SetDisplayLabel(DisplayLabelT&& value) {
    m_displayLabelHasBeenSet = true;
    m_displayLabel = std::forward<DisplayLabelT>(value);
  }
  template <typename DisplayLabelT = Aws::String>
  RadiusSettings& WithDisplayLabel(DisplayLabelT&& value) {
    SetDisplayLabel(std::forward<DisplayLabelT>(value));
    return *this;
  }
 
 
  inline bool GetUseSameUsername() const { return m_useSameUsername; }
  inline bool UseSameUsernameHasBeenSet() const { return m_useSameUsernameHasBeenSet; }
  inline void SetUseSameUsername(bool value) {
    m_useSameUsernameHasBeenSet = true;
    m_useSameUsername = value;
  }
  inline RadiusSettings& WithUseSameUsername(bool value) {
    SetUseSameUsername(value);
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_radiusServers;
 
  Aws::Vector<Aws::String> m_radiusServersIpv6;
 
  int m_radiusPort{0};
 
  int m_radiusTimeout{0};
 
  int m_radiusRetries{0};
 
  Aws::String m_sharedSecret;
 
  RadiusAuthenticationProtocol m_authenticationProtocol{RadiusAuthenticationProtocol::NOT_SET};
 
  Aws::String m_displayLabel;
 
  bool m_useSameUsername{false};
  bool m_radiusServersHasBeenSet = false;
  bool m_radiusServersIpv6HasBeenSet = false;
  bool m_radiusPortHasBeenSet = false;
  bool m_radiusTimeoutHasBeenSet = false;
  bool m_radiusRetriesHasBeenSet = false;
  bool m_sharedSecretHasBeenSet = false;
  bool m_authenticationProtocolHasBeenSet = false;
  bool m_displayLabelHasBeenSet = false;
  bool m_useSameUsernameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DirectoryService
}  // namespace Aws