DBProxyTargetGroup.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/rds/model/ConnectionPoolConfigurationInfo.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace RDS {
namespace Model {
 
class DBProxyTargetGroup {
 public:
  AWS_RDS_API DBProxyTargetGroup() = default;
  AWS_RDS_API DBProxyTargetGroup(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_RDS_API DBProxyTargetGroup& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_RDS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_RDS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetDBProxyName() const { return m_dBProxyName; }
  inline bool DBProxyNameHasBeenSet() const { return m_dBProxyNameHasBeenSet; }
  template <typename DBProxyNameT = Aws::String>
  void SetDBProxyName(DBProxyNameT&& value) {
    m_dBProxyNameHasBeenSet = true;
    m_dBProxyName = std::forward<DBProxyNameT>(value);
  }
  template <typename DBProxyNameT = Aws::String>
  DBProxyTargetGroup& WithDBProxyName(DBProxyNameT&& value) {
    SetDBProxyName(std::forward<DBProxyNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetGroupName() const { return m_targetGroupName; }
  inline bool TargetGroupNameHasBeenSet() const { return m_targetGroupNameHasBeenSet; }
  template <typename TargetGroupNameT = Aws::String>
  void SetTargetGroupName(TargetGroupNameT&& value) {
    m_targetGroupNameHasBeenSet = true;
    m_targetGroupName = std::forward<TargetGroupNameT>(value);
  }
  template <typename TargetGroupNameT = Aws::String>
  DBProxyTargetGroup& WithTargetGroupName(TargetGroupNameT&& value) {
    SetTargetGroupName(std::forward<TargetGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetGroupArn() const { return m_targetGroupArn; }
  inline bool TargetGroupArnHasBeenSet() const { return m_targetGroupArnHasBeenSet; }
  template <typename TargetGroupArnT = Aws::String>
  void SetTargetGroupArn(TargetGroupArnT&& value) {
    m_targetGroupArnHasBeenSet = true;
    m_targetGroupArn = std::forward<TargetGroupArnT>(value);
  }
  template <typename TargetGroupArnT = Aws::String>
  DBProxyTargetGroup& WithTargetGroupArn(TargetGroupArnT&& value) {
    SetTargetGroupArn(std::forward<TargetGroupArnT>(value));
    return *this;
  }
 
 
  inline bool GetIsDefault() const { return m_isDefault; }
  inline bool IsDefaultHasBeenSet() const { return m_isDefaultHasBeenSet; }
  inline void SetIsDefault(bool value) {
    m_isDefaultHasBeenSet = true;
    m_isDefault = value;
  }
  inline DBProxyTargetGroup& WithIsDefault(bool value) {
    SetIsDefault(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = Aws::String>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = Aws::String>
  DBProxyTargetGroup& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const ConnectionPoolConfigurationInfo& GetConnectionPoolConfig() const { return m_connectionPoolConfig; }
  inline bool ConnectionPoolConfigHasBeenSet() const { return m_connectionPoolConfigHasBeenSet; }
  template <typename ConnectionPoolConfigT = ConnectionPoolConfigurationInfo>
  void SetConnectionPoolConfig(ConnectionPoolConfigT&& value) {
    m_connectionPoolConfigHasBeenSet = true;
    m_connectionPoolConfig = std::forward<ConnectionPoolConfigT>(value);
  }
  template <typename ConnectionPoolConfigT = ConnectionPoolConfigurationInfo>
  DBProxyTargetGroup& WithConnectionPoolConfig(ConnectionPoolConfigT&& value) {
    SetConnectionPoolConfig(std::forward<ConnectionPoolConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedDate() const { return m_createdDate; }
  inline bool CreatedDateHasBeenSet() const { return m_createdDateHasBeenSet; }
  template <typename CreatedDateT = Aws::Utils::DateTime>
  void SetCreatedDate(CreatedDateT&& value) {
    m_createdDateHasBeenSet = true;
    m_createdDate = std::forward<CreatedDateT>(value);
  }
  template <typename CreatedDateT = Aws::Utils::DateTime>
  DBProxyTargetGroup& WithCreatedDate(CreatedDateT&& value) {
    SetCreatedDate(std::forward<CreatedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUpdatedDate() const { return m_updatedDate; }
  inline bool UpdatedDateHasBeenSet() const { return m_updatedDateHasBeenSet; }
  template <typename UpdatedDateT = Aws::Utils::DateTime>
  void SetUpdatedDate(UpdatedDateT&& value) {
    m_updatedDateHasBeenSet = true;
    m_updatedDate = std::forward<UpdatedDateT>(value);
  }
  template <typename UpdatedDateT = Aws::Utils::DateTime>
  DBProxyTargetGroup& WithUpdatedDate(UpdatedDateT&& value) {
    SetUpdatedDate(std::forward<UpdatedDateT>(value));
    return *this;
  }
 private:
  Aws::String m_dBProxyName;
 
  Aws::String m_targetGroupName;
 
  Aws::String m_targetGroupArn;
 
  bool m_isDefault{false};
 
  Aws::String m_status;
 
  ConnectionPoolConfigurationInfo m_connectionPoolConfig;
 
  Aws::Utils::DateTime m_createdDate{};
 
  Aws::Utils::DateTime m_updatedDate{};
  bool m_dBProxyNameHasBeenSet = false;
  bool m_targetGroupNameHasBeenSet = false;
  bool m_targetGroupArnHasBeenSet = false;
  bool m_isDefaultHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_connectionPoolConfigHasBeenSet = false;
  bool m_createdDateHasBeenSet = false;
  bool m_updatedDateHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace RDS
}  // namespace Aws