Statement.h

 
#pragma once
#include <aws/wafv2/WAFV2_EXPORTS.h>
#include <aws/wafv2/model/ByteMatchStatement.h>
#include <aws/wafv2/model/SqliMatchStatement.h>
#include <aws/wafv2/model/XssMatchStatement.h>
#include <aws/wafv2/model/SizeConstraintStatement.h>
#include <aws/wafv2/model/GeoMatchStatement.h>
#include <aws/wafv2/model/RuleGroupReferenceStatement.h>
#include <aws/wafv2/model/IPSetReferenceStatement.h>
#include <aws/wafv2/model/RegexPatternSetReferenceStatement.h>
#include <aws/wafv2/model/LabelMatchStatement.h>
#include <aws/wafv2/model/RegexMatchStatement.h>
#include <aws/wafv2/model/AsnMatchStatement.h>
#include <aws/core/utils/memory/stl/AWSAllocator.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace WAFV2
{
namespace Model
{
  class RateBasedStatement;
  class AndStatement;
  class OrStatement;
  class NotStatement;
  class ManagedRuleGroupStatement;
 
  class Statement
  {
  public:
    AWS_WAFV2_API Statement() = default;
    AWS_WAFV2_API Statement(Aws::Utils::Json::JsonView jsonValue);
    AWS_WAFV2_API Statement& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_WAFV2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const ByteMatchStatement& GetByteMatchStatement() const { return m_byteMatchStatement; }
    inline bool ByteMatchStatementHasBeenSet() const { return m_byteMatchStatementHasBeenSet; }
    template<typename ByteMatchStatementT = ByteMatchStatement>
    void SetByteMatchStatement(ByteMatchStatementT&& value) { m_byteMatchStatementHasBeenSet = true; m_byteMatchStatement = std::forward<ByteMatchStatementT>(value); }
    template<typename ByteMatchStatementT = ByteMatchStatement>
    Statement& WithByteMatchStatement(ByteMatchStatementT&& value) { SetByteMatchStatement(std::forward<ByteMatchStatementT>(value)); return *this;}
 
 
    inline const SqliMatchStatement& GetSqliMatchStatement() const { return m_sqliMatchStatement; }
    inline bool SqliMatchStatementHasBeenSet() const { return m_sqliMatchStatementHasBeenSet; }
    template<typename SqliMatchStatementT = SqliMatchStatement>
    void SetSqliMatchStatement(SqliMatchStatementT&& value) { m_sqliMatchStatementHasBeenSet = true; m_sqliMatchStatement = std::forward<SqliMatchStatementT>(value); }
    template<typename SqliMatchStatementT = SqliMatchStatement>
    Statement& WithSqliMatchStatement(SqliMatchStatementT&& value) { SetSqliMatchStatement(std::forward<SqliMatchStatementT>(value)); return *this;}
 
 
    inline const XssMatchStatement& GetXssMatchStatement() const { return m_xssMatchStatement; }
    inline bool XssMatchStatementHasBeenSet() const { return m_xssMatchStatementHasBeenSet; }
    template<typename XssMatchStatementT = XssMatchStatement>
    void SetXssMatchStatement(XssMatchStatementT&& value) { m_xssMatchStatementHasBeenSet = true; m_xssMatchStatement = std::forward<XssMatchStatementT>(value); }
    template<typename XssMatchStatementT = XssMatchStatement>
    Statement& WithXssMatchStatement(XssMatchStatementT&& value) { SetXssMatchStatement(std::forward<XssMatchStatementT>(value)); return *this;}
 
 
    inline const SizeConstraintStatement& GetSizeConstraintStatement() const { return m_sizeConstraintStatement; }
    inline bool SizeConstraintStatementHasBeenSet() const { return m_sizeConstraintStatementHasBeenSet; }
    template<typename SizeConstraintStatementT = SizeConstraintStatement>
    void SetSizeConstraintStatement(SizeConstraintStatementT&& value) { m_sizeConstraintStatementHasBeenSet = true; m_sizeConstraintStatement = std::forward<SizeConstraintStatementT>(value); }
    template<typename SizeConstraintStatementT = SizeConstraintStatement>
    Statement& WithSizeConstraintStatement(SizeConstraintStatementT&& value) { SetSizeConstraintStatement(std::forward<SizeConstraintStatementT>(value)); return *this;}
 
 
    inline const GeoMatchStatement& GetGeoMatchStatement() const { return m_geoMatchStatement; }
    inline bool GeoMatchStatementHasBeenSet() const { return m_geoMatchStatementHasBeenSet; }
    template<typename GeoMatchStatementT = GeoMatchStatement>
    void SetGeoMatchStatement(GeoMatchStatementT&& value) { m_geoMatchStatementHasBeenSet = true; m_geoMatchStatement = std::forward<GeoMatchStatementT>(value); }
    template<typename GeoMatchStatementT = GeoMatchStatement>
    Statement& WithGeoMatchStatement(GeoMatchStatementT&& value) { SetGeoMatchStatement(std::forward<GeoMatchStatementT>(value)); return *this;}
 
 
    inline const RuleGroupReferenceStatement& GetRuleGroupReferenceStatement() const { return m_ruleGroupReferenceStatement; }
    inline bool RuleGroupReferenceStatementHasBeenSet() const { return m_ruleGroupReferenceStatementHasBeenSet; }
    template<typename RuleGroupReferenceStatementT = RuleGroupReferenceStatement>
    void SetRuleGroupReferenceStatement(RuleGroupReferenceStatementT&& value) { m_ruleGroupReferenceStatementHasBeenSet = true; m_ruleGroupReferenceStatement = std::forward<RuleGroupReferenceStatementT>(value); }
    template<typename RuleGroupReferenceStatementT = RuleGroupReferenceStatement>
    Statement& WithRuleGroupReferenceStatement(RuleGroupReferenceStatementT&& value) { SetRuleGroupReferenceStatement(std::forward<RuleGroupReferenceStatementT>(value)); return *this;}
 
 
    inline const IPSetReferenceStatement& GetIPSetReferenceStatement() const { return m_iPSetReferenceStatement; }
    inline bool IPSetReferenceStatementHasBeenSet() const { return m_iPSetReferenceStatementHasBeenSet; }
    template<typename IPSetReferenceStatementT = IPSetReferenceStatement>
    void SetIPSetReferenceStatement(IPSetReferenceStatementT&& value) { m_iPSetReferenceStatementHasBeenSet = true; m_iPSetReferenceStatement = std::forward<IPSetReferenceStatementT>(value); }
    template<typename IPSetReferenceStatementT = IPSetReferenceStatement>
    Statement& WithIPSetReferenceStatement(IPSetReferenceStatementT&& value) { SetIPSetReferenceStatement(std::forward<IPSetReferenceStatementT>(value)); return *this;}
 
 
    inline const RegexPatternSetReferenceStatement& GetRegexPatternSetReferenceStatement() const { return m_regexPatternSetReferenceStatement; }
    inline bool RegexPatternSetReferenceStatementHasBeenSet() const { return m_regexPatternSetReferenceStatementHasBeenSet; }
    template<typename RegexPatternSetReferenceStatementT = RegexPatternSetReferenceStatement>
    void SetRegexPatternSetReferenceStatement(RegexPatternSetReferenceStatementT&& value) { m_regexPatternSetReferenceStatementHasBeenSet = true; m_regexPatternSetReferenceStatement = std::forward<RegexPatternSetReferenceStatementT>(value); }
    template<typename RegexPatternSetReferenceStatementT = RegexPatternSetReferenceStatement>
    Statement& WithRegexPatternSetReferenceStatement(RegexPatternSetReferenceStatementT&& value) { SetRegexPatternSetReferenceStatement(std::forward<RegexPatternSetReferenceStatementT>(value)); return *this;}
 
 
    inline const RateBasedStatement& GetRateBasedStatement() const{
      return *m_rateBasedStatement;
    }
    inline bool RateBasedStatementHasBeenSet() const { return m_rateBasedStatementHasBeenSet; }
    template<typename RateBasedStatementT = RateBasedStatement>
    void SetRateBasedStatement(RateBasedStatementT&& value) {
      m_rateBasedStatementHasBeenSet = true; 
      m_rateBasedStatement = Aws::MakeShared<RateBasedStatement>("Statement", std::forward<RateBasedStatementT>(value));
    }
    template<typename RateBasedStatementT = RateBasedStatement>
    Statement& WithRateBasedStatement(RateBasedStatementT&& value) { SetRateBasedStatement(std::forward<RateBasedStatementT>(value)); return *this;}
 
 
    inline const AndStatement& GetAndStatement() const{
      return *m_andStatement;
    }
    inline bool AndStatementHasBeenSet() const { return m_andStatementHasBeenSet; }
    template<typename AndStatementT = AndStatement>
    void SetAndStatement(AndStatementT&& value) {
      m_andStatementHasBeenSet = true; 
      m_andStatement = Aws::MakeShared<AndStatement>("Statement", std::forward<AndStatementT>(value));
    }
    template<typename AndStatementT = AndStatement>
    Statement& WithAndStatement(AndStatementT&& value) { SetAndStatement(std::forward<AndStatementT>(value)); return *this;}
 
 
    inline const OrStatement& GetOrStatement() const{
      return *m_orStatement;
    }
    inline bool OrStatementHasBeenSet() const { return m_orStatementHasBeenSet; }
    template<typename OrStatementT = OrStatement>
    void SetOrStatement(OrStatementT&& value) {
      m_orStatementHasBeenSet = true; 
      m_orStatement = Aws::MakeShared<OrStatement>("Statement", std::forward<OrStatementT>(value));
    }
    template<typename OrStatementT = OrStatement>
    Statement& WithOrStatement(OrStatementT&& value) { SetOrStatement(std::forward<OrStatementT>(value)); return *this;}
 
 
    inline const NotStatement& GetNotStatement() const{
      return *m_notStatement;
    }
    inline bool NotStatementHasBeenSet() const { return m_notStatementHasBeenSet; }
    template<typename NotStatementT = NotStatement>
    void SetNotStatement(NotStatementT&& value) {
      m_notStatementHasBeenSet = true; 
      m_notStatement = Aws::MakeShared<NotStatement>("Statement", std::forward<NotStatementT>(value));
    }
    template<typename NotStatementT = NotStatement>
    Statement& WithNotStatement(NotStatementT&& value) { SetNotStatement(std::forward<NotStatementT>(value)); return *this;}
 
 
    inline const ManagedRuleGroupStatement& GetManagedRuleGroupStatement() const{
      return *m_managedRuleGroupStatement;
    }
    inline bool ManagedRuleGroupStatementHasBeenSet() const { return m_managedRuleGroupStatementHasBeenSet; }
    template<typename ManagedRuleGroupStatementT = ManagedRuleGroupStatement>
    void SetManagedRuleGroupStatement(ManagedRuleGroupStatementT&& value) {
      m_managedRuleGroupStatementHasBeenSet = true; 
      m_managedRuleGroupStatement = Aws::MakeShared<ManagedRuleGroupStatement>("Statement", std::forward<ManagedRuleGroupStatementT>(value));
    }
    template<typename ManagedRuleGroupStatementT = ManagedRuleGroupStatement>
    Statement& WithManagedRuleGroupStatement(ManagedRuleGroupStatementT&& value) { SetManagedRuleGroupStatement(std::forward<ManagedRuleGroupStatementT>(value)); return *this;}
 
 
    inline const LabelMatchStatement& GetLabelMatchStatement() const { return m_labelMatchStatement; }
    inline bool LabelMatchStatementHasBeenSet() const { return m_labelMatchStatementHasBeenSet; }
    template<typename LabelMatchStatementT = LabelMatchStatement>
    void SetLabelMatchStatement(LabelMatchStatementT&& value) { m_labelMatchStatementHasBeenSet = true; m_labelMatchStatement = std::forward<LabelMatchStatementT>(value); }
    template<typename LabelMatchStatementT = LabelMatchStatement>
    Statement& WithLabelMatchStatement(LabelMatchStatementT&& value) { SetLabelMatchStatement(std::forward<LabelMatchStatementT>(value)); return *this;}
 
 
    inline const RegexMatchStatement& GetRegexMatchStatement() const { return m_regexMatchStatement; }
    inline bool RegexMatchStatementHasBeenSet() const { return m_regexMatchStatementHasBeenSet; }
    template<typename RegexMatchStatementT = RegexMatchStatement>
    void SetRegexMatchStatement(RegexMatchStatementT&& value) { m_regexMatchStatementHasBeenSet = true; m_regexMatchStatement = std::forward<RegexMatchStatementT>(value); }
    template<typename RegexMatchStatementT = RegexMatchStatement>
    Statement& WithRegexMatchStatement(RegexMatchStatementT&& value) { SetRegexMatchStatement(std::forward<RegexMatchStatementT>(value)); return *this;}
 
 
    inline const AsnMatchStatement& GetAsnMatchStatement() const { return m_asnMatchStatement; }
    inline bool AsnMatchStatementHasBeenSet() const { return m_asnMatchStatementHasBeenSet; }
    template<typename AsnMatchStatementT = AsnMatchStatement>
    void SetAsnMatchStatement(AsnMatchStatementT&& value) { m_asnMatchStatementHasBeenSet = true; m_asnMatchStatement = std::forward<AsnMatchStatementT>(value); }
    template<typename AsnMatchStatementT = AsnMatchStatement>
    Statement& WithAsnMatchStatement(AsnMatchStatementT&& value) { SetAsnMatchStatement(std::forward<AsnMatchStatementT>(value)); return *this;}
  private:
 
    ByteMatchStatement m_byteMatchStatement;
    bool m_byteMatchStatementHasBeenSet = false;
 
    SqliMatchStatement m_sqliMatchStatement;
    bool m_sqliMatchStatementHasBeenSet = false;
 
    XssMatchStatement m_xssMatchStatement;
    bool m_xssMatchStatementHasBeenSet = false;
 
    SizeConstraintStatement m_sizeConstraintStatement;
    bool m_sizeConstraintStatementHasBeenSet = false;
 
    GeoMatchStatement m_geoMatchStatement;
    bool m_geoMatchStatementHasBeenSet = false;
 
    RuleGroupReferenceStatement m_ruleGroupReferenceStatement;
    bool m_ruleGroupReferenceStatementHasBeenSet = false;
 
    IPSetReferenceStatement m_iPSetReferenceStatement;
    bool m_iPSetReferenceStatementHasBeenSet = false;
 
    RegexPatternSetReferenceStatement m_regexPatternSetReferenceStatement;
    bool m_regexPatternSetReferenceStatementHasBeenSet = false;
 
    std::shared_ptr<RateBasedStatement> m_rateBasedStatement;
    bool m_rateBasedStatementHasBeenSet = false;
 
    std::shared_ptr<AndStatement> m_andStatement;
    bool m_andStatementHasBeenSet = false;
 
    std::shared_ptr<OrStatement> m_orStatement;
    bool m_orStatementHasBeenSet = false;
 
    std::shared_ptr<NotStatement> m_notStatement;
    bool m_notStatementHasBeenSet = false;
 
    std::shared_ptr<ManagedRuleGroupStatement> m_managedRuleGroupStatement;
    bool m_managedRuleGroupStatementHasBeenSet = false;
 
    LabelMatchStatement m_labelMatchStatement;
    bool m_labelMatchStatementHasBeenSet = false;
 
    RegexMatchStatement m_regexMatchStatement;
    bool m_regexMatchStatementHasBeenSet = false;
 
    AsnMatchStatement m_asnMatchStatement;
    bool m_asnMatchStatementHasBeenSet = false;
  };
 
} // namespace Model
} // namespace WAFV2
} // namespace Aws