Action.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/elasticloadbalancingv2/ElasticLoadBalancingv2_EXPORTS.h>
#include <aws/elasticloadbalancingv2/model/ActionTypeEnum.h>
#include <aws/elasticloadbalancingv2/model/AuthenticateCognitoActionConfig.h>
#include <aws/elasticloadbalancingv2/model/AuthenticateOidcActionConfig.h>
#include <aws/elasticloadbalancingv2/model/FixedResponseActionConfig.h>
#include <aws/elasticloadbalancingv2/model/ForwardActionConfig.h>
#include <aws/elasticloadbalancingv2/model/JwtValidationActionConfig.h>
#include <aws/elasticloadbalancingv2/model/RedirectActionConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace ElasticLoadBalancingv2 {
namespace Model {
 
class Action {
 public:
  AWS_ELASTICLOADBALANCINGV2_API Action() = default;
  AWS_ELASTICLOADBALANCINGV2_API Action(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_ELASTICLOADBALANCINGV2_API Action& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_ELASTICLOADBALANCINGV2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index,
                                                     const char* locationValue) const;
  AWS_ELASTICLOADBALANCINGV2_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline ActionTypeEnum GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(ActionTypeEnum value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline Action& WithType(ActionTypeEnum value) {
    SetType(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>
  Action& WithTargetGroupArn(TargetGroupArnT&& value) {
    SetTargetGroupArn(std::forward<TargetGroupArnT>(value));
    return *this;
  }
 
 
  inline const AuthenticateOidcActionConfig& GetAuthenticateOidcConfig() const { return m_authenticateOidcConfig; }
  inline bool AuthenticateOidcConfigHasBeenSet() const { return m_authenticateOidcConfigHasBeenSet; }
  template <typename AuthenticateOidcConfigT = AuthenticateOidcActionConfig>
  void SetAuthenticateOidcConfig(AuthenticateOidcConfigT&& value) {
    m_authenticateOidcConfigHasBeenSet = true;
    m_authenticateOidcConfig = std::forward<AuthenticateOidcConfigT>(value);
  }
  template <typename AuthenticateOidcConfigT = AuthenticateOidcActionConfig>
  Action& WithAuthenticateOidcConfig(AuthenticateOidcConfigT&& value) {
    SetAuthenticateOidcConfig(std::forward<AuthenticateOidcConfigT>(value));
    return *this;
  }
 
 
  inline const AuthenticateCognitoActionConfig& GetAuthenticateCognitoConfig() const { return m_authenticateCognitoConfig; }
  inline bool AuthenticateCognitoConfigHasBeenSet() const { return m_authenticateCognitoConfigHasBeenSet; }
  template <typename AuthenticateCognitoConfigT = AuthenticateCognitoActionConfig>
  void SetAuthenticateCognitoConfig(AuthenticateCognitoConfigT&& value) {
    m_authenticateCognitoConfigHasBeenSet = true;
    m_authenticateCognitoConfig = std::forward<AuthenticateCognitoConfigT>(value);
  }
  template <typename AuthenticateCognitoConfigT = AuthenticateCognitoActionConfig>
  Action& WithAuthenticateCognitoConfig(AuthenticateCognitoConfigT&& value) {
    SetAuthenticateCognitoConfig(std::forward<AuthenticateCognitoConfigT>(value));
    return *this;
  }
 
 
  inline int GetOrder() const { return m_order; }
  inline bool OrderHasBeenSet() const { return m_orderHasBeenSet; }
  inline void SetOrder(int value) {
    m_orderHasBeenSet = true;
    m_order = value;
  }
  inline Action& WithOrder(int value) {
    SetOrder(value);
    return *this;
  }
 
 
  inline const RedirectActionConfig& GetRedirectConfig() const { return m_redirectConfig; }
  inline bool RedirectConfigHasBeenSet() const { return m_redirectConfigHasBeenSet; }
  template <typename RedirectConfigT = RedirectActionConfig>
  void SetRedirectConfig(RedirectConfigT&& value) {
    m_redirectConfigHasBeenSet = true;
    m_redirectConfig = std::forward<RedirectConfigT>(value);
  }
  template <typename RedirectConfigT = RedirectActionConfig>
  Action& WithRedirectConfig(RedirectConfigT&& value) {
    SetRedirectConfig(std::forward<RedirectConfigT>(value));
    return *this;
  }
 
 
  inline const FixedResponseActionConfig& GetFixedResponseConfig() const { return m_fixedResponseConfig; }
  inline bool FixedResponseConfigHasBeenSet() const { return m_fixedResponseConfigHasBeenSet; }
  template <typename FixedResponseConfigT = FixedResponseActionConfig>
  void SetFixedResponseConfig(FixedResponseConfigT&& value) {
    m_fixedResponseConfigHasBeenSet = true;
    m_fixedResponseConfig = std::forward<FixedResponseConfigT>(value);
  }
  template <typename FixedResponseConfigT = FixedResponseActionConfig>
  Action& WithFixedResponseConfig(FixedResponseConfigT&& value) {
    SetFixedResponseConfig(std::forward<FixedResponseConfigT>(value));
    return *this;
  }
 
 
  inline const ForwardActionConfig& GetForwardConfig() const { return m_forwardConfig; }
  inline bool ForwardConfigHasBeenSet() const { return m_forwardConfigHasBeenSet; }
  template <typename ForwardConfigT = ForwardActionConfig>
  void SetForwardConfig(ForwardConfigT&& value) {
    m_forwardConfigHasBeenSet = true;
    m_forwardConfig = std::forward<ForwardConfigT>(value);
  }
  template <typename ForwardConfigT = ForwardActionConfig>
  Action& WithForwardConfig(ForwardConfigT&& value) {
    SetForwardConfig(std::forward<ForwardConfigT>(value));
    return *this;
  }
 
 
  inline const JwtValidationActionConfig& GetJwtValidationConfig() const { return m_jwtValidationConfig; }
  inline bool JwtValidationConfigHasBeenSet() const { return m_jwtValidationConfigHasBeenSet; }
  template <typename JwtValidationConfigT = JwtValidationActionConfig>
  void SetJwtValidationConfig(JwtValidationConfigT&& value) {
    m_jwtValidationConfigHasBeenSet = true;
    m_jwtValidationConfig = std::forward<JwtValidationConfigT>(value);
  }
  template <typename JwtValidationConfigT = JwtValidationActionConfig>
  Action& WithJwtValidationConfig(JwtValidationConfigT&& value) {
    SetJwtValidationConfig(std::forward<JwtValidationConfigT>(value));
    return *this;
  }
 private:
  ActionTypeEnum m_type{ActionTypeEnum::NOT_SET};
 
  Aws::String m_targetGroupArn;
 
  AuthenticateOidcActionConfig m_authenticateOidcConfig;
 
  AuthenticateCognitoActionConfig m_authenticateCognitoConfig;
 
  int m_order{0};
 
  RedirectActionConfig m_redirectConfig;
 
  FixedResponseActionConfig m_fixedResponseConfig;
 
  ForwardActionConfig m_forwardConfig;
 
  JwtValidationActionConfig m_jwtValidationConfig;
  bool m_typeHasBeenSet = false;
  bool m_targetGroupArnHasBeenSet = false;
  bool m_authenticateOidcConfigHasBeenSet = false;
  bool m_authenticateCognitoConfigHasBeenSet = false;
  bool m_orderHasBeenSet = false;
  bool m_redirectConfigHasBeenSet = false;
  bool m_fixedResponseConfigHasBeenSet = false;
  bool m_forwardConfigHasBeenSet = false;
  bool m_jwtValidationConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElasticLoadBalancingv2
}  // namespace Aws