358 lines
15 KiB
C++
358 lines
15 KiB
C++
/**
|
|
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
* SPDX-License-Identifier: Apache-2.0.
|
|
*/
|
|
|
|
#include <aws/wafv2/model/ParameterExceptionField.h>
|
|
#include <aws/core/utils/HashingUtils.h>
|
|
#include <aws/core/Globals.h>
|
|
#include <aws/core/utils/EnumParseOverflowContainer.h>
|
|
|
|
using namespace Aws::Utils;
|
|
|
|
|
|
namespace Aws
|
|
{
|
|
namespace WAFV2
|
|
{
|
|
namespace Model
|
|
{
|
|
namespace ParameterExceptionFieldMapper
|
|
{
|
|
|
|
static const int WEB_ACL_HASH = HashingUtils::HashString("WEB_ACL");
|
|
static const int RULE_GROUP_HASH = HashingUtils::HashString("RULE_GROUP");
|
|
static const int REGEX_PATTERN_SET_HASH = HashingUtils::HashString("REGEX_PATTERN_SET");
|
|
static const int IP_SET_HASH = HashingUtils::HashString("IP_SET");
|
|
static const int MANAGED_RULE_SET_HASH = HashingUtils::HashString("MANAGED_RULE_SET");
|
|
static const int RULE_HASH = HashingUtils::HashString("RULE");
|
|
static const int EXCLUDED_RULE_HASH = HashingUtils::HashString("EXCLUDED_RULE");
|
|
static const int STATEMENT_HASH = HashingUtils::HashString("STATEMENT");
|
|
static const int BYTE_MATCH_STATEMENT_HASH = HashingUtils::HashString("BYTE_MATCH_STATEMENT");
|
|
static const int SQLI_MATCH_STATEMENT_HASH = HashingUtils::HashString("SQLI_MATCH_STATEMENT");
|
|
static const int XSS_MATCH_STATEMENT_HASH = HashingUtils::HashString("XSS_MATCH_STATEMENT");
|
|
static const int SIZE_CONSTRAINT_STATEMENT_HASH = HashingUtils::HashString("SIZE_CONSTRAINT_STATEMENT");
|
|
static const int GEO_MATCH_STATEMENT_HASH = HashingUtils::HashString("GEO_MATCH_STATEMENT");
|
|
static const int RATE_BASED_STATEMENT_HASH = HashingUtils::HashString("RATE_BASED_STATEMENT");
|
|
static const int RULE_GROUP_REFERENCE_STATEMENT_HASH = HashingUtils::HashString("RULE_GROUP_REFERENCE_STATEMENT");
|
|
static const int REGEX_PATTERN_REFERENCE_STATEMENT_HASH = HashingUtils::HashString("REGEX_PATTERN_REFERENCE_STATEMENT");
|
|
static const int IP_SET_REFERENCE_STATEMENT_HASH = HashingUtils::HashString("IP_SET_REFERENCE_STATEMENT");
|
|
static const int MANAGED_RULE_SET_STATEMENT_HASH = HashingUtils::HashString("MANAGED_RULE_SET_STATEMENT");
|
|
static const int AND_STATEMENT_HASH = HashingUtils::HashString("AND_STATEMENT");
|
|
static const int OR_STATEMENT_HASH = HashingUtils::HashString("OR_STATEMENT");
|
|
static const int NOT_STATEMENT_HASH = HashingUtils::HashString("NOT_STATEMENT");
|
|
static const int IP_ADDRESS_HASH = HashingUtils::HashString("IP_ADDRESS");
|
|
static const int IP_ADDRESS_VERSION_HASH = HashingUtils::HashString("IP_ADDRESS_VERSION");
|
|
static const int FIELD_TO_MATCH_HASH = HashingUtils::HashString("FIELD_TO_MATCH");
|
|
static const int TEXT_TRANSFORMATION_HASH = HashingUtils::HashString("TEXT_TRANSFORMATION");
|
|
static const int SINGLE_QUERY_ARGUMENT_HASH = HashingUtils::HashString("SINGLE_QUERY_ARGUMENT");
|
|
static const int SINGLE_HEADER_HASH = HashingUtils::HashString("SINGLE_HEADER");
|
|
static const int DEFAULT_ACTION_HASH = HashingUtils::HashString("DEFAULT_ACTION");
|
|
static const int RULE_ACTION_HASH = HashingUtils::HashString("RULE_ACTION");
|
|
static const int ENTITY_LIMIT_HASH = HashingUtils::HashString("ENTITY_LIMIT");
|
|
static const int OVERRIDE_ACTION_HASH = HashingUtils::HashString("OVERRIDE_ACTION");
|
|
static const int SCOPE_VALUE_HASH = HashingUtils::HashString("SCOPE_VALUE");
|
|
static const int RESOURCE_ARN_HASH = HashingUtils::HashString("RESOURCE_ARN");
|
|
static const int RESOURCE_TYPE_HASH = HashingUtils::HashString("RESOURCE_TYPE");
|
|
static const int TAGS_HASH = HashingUtils::HashString("TAGS");
|
|
static const int TAG_KEYS_HASH = HashingUtils::HashString("TAG_KEYS");
|
|
static const int METRIC_NAME_HASH = HashingUtils::HashString("METRIC_NAME");
|
|
static const int FIREWALL_MANAGER_STATEMENT_HASH = HashingUtils::HashString("FIREWALL_MANAGER_STATEMENT");
|
|
static const int FALLBACK_BEHAVIOR_HASH = HashingUtils::HashString("FALLBACK_BEHAVIOR");
|
|
static const int POSITION_HASH = HashingUtils::HashString("POSITION");
|
|
static const int FORWARDED_IP_CONFIG_HASH = HashingUtils::HashString("FORWARDED_IP_CONFIG");
|
|
static const int IP_SET_FORWARDED_IP_CONFIG_HASH = HashingUtils::HashString("IP_SET_FORWARDED_IP_CONFIG");
|
|
static const int HEADER_NAME_HASH = HashingUtils::HashString("HEADER_NAME");
|
|
|
|
|
|
ParameterExceptionField GetParameterExceptionFieldForName(const Aws::String& name)
|
|
{
|
|
int hashCode = HashingUtils::HashString(name.c_str());
|
|
if (hashCode == WEB_ACL_HASH)
|
|
{
|
|
return ParameterExceptionField::WEB_ACL;
|
|
}
|
|
else if (hashCode == RULE_GROUP_HASH)
|
|
{
|
|
return ParameterExceptionField::RULE_GROUP;
|
|
}
|
|
else if (hashCode == REGEX_PATTERN_SET_HASH)
|
|
{
|
|
return ParameterExceptionField::REGEX_PATTERN_SET;
|
|
}
|
|
else if (hashCode == IP_SET_HASH)
|
|
{
|
|
return ParameterExceptionField::IP_SET;
|
|
}
|
|
else if (hashCode == MANAGED_RULE_SET_HASH)
|
|
{
|
|
return ParameterExceptionField::MANAGED_RULE_SET;
|
|
}
|
|
else if (hashCode == RULE_HASH)
|
|
{
|
|
return ParameterExceptionField::RULE;
|
|
}
|
|
else if (hashCode == EXCLUDED_RULE_HASH)
|
|
{
|
|
return ParameterExceptionField::EXCLUDED_RULE;
|
|
}
|
|
else if (hashCode == STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::STATEMENT;
|
|
}
|
|
else if (hashCode == BYTE_MATCH_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::BYTE_MATCH_STATEMENT;
|
|
}
|
|
else if (hashCode == SQLI_MATCH_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::SQLI_MATCH_STATEMENT;
|
|
}
|
|
else if (hashCode == XSS_MATCH_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::XSS_MATCH_STATEMENT;
|
|
}
|
|
else if (hashCode == SIZE_CONSTRAINT_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::SIZE_CONSTRAINT_STATEMENT;
|
|
}
|
|
else if (hashCode == GEO_MATCH_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::GEO_MATCH_STATEMENT;
|
|
}
|
|
else if (hashCode == RATE_BASED_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::RATE_BASED_STATEMENT;
|
|
}
|
|
else if (hashCode == RULE_GROUP_REFERENCE_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::RULE_GROUP_REFERENCE_STATEMENT;
|
|
}
|
|
else if (hashCode == REGEX_PATTERN_REFERENCE_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::REGEX_PATTERN_REFERENCE_STATEMENT;
|
|
}
|
|
else if (hashCode == IP_SET_REFERENCE_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::IP_SET_REFERENCE_STATEMENT;
|
|
}
|
|
else if (hashCode == MANAGED_RULE_SET_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::MANAGED_RULE_SET_STATEMENT;
|
|
}
|
|
else if (hashCode == AND_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::AND_STATEMENT;
|
|
}
|
|
else if (hashCode == OR_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::OR_STATEMENT;
|
|
}
|
|
else if (hashCode == NOT_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::NOT_STATEMENT;
|
|
}
|
|
else if (hashCode == IP_ADDRESS_HASH)
|
|
{
|
|
return ParameterExceptionField::IP_ADDRESS;
|
|
}
|
|
else if (hashCode == IP_ADDRESS_VERSION_HASH)
|
|
{
|
|
return ParameterExceptionField::IP_ADDRESS_VERSION;
|
|
}
|
|
else if (hashCode == FIELD_TO_MATCH_HASH)
|
|
{
|
|
return ParameterExceptionField::FIELD_TO_MATCH;
|
|
}
|
|
else if (hashCode == TEXT_TRANSFORMATION_HASH)
|
|
{
|
|
return ParameterExceptionField::TEXT_TRANSFORMATION;
|
|
}
|
|
else if (hashCode == SINGLE_QUERY_ARGUMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::SINGLE_QUERY_ARGUMENT;
|
|
}
|
|
else if (hashCode == SINGLE_HEADER_HASH)
|
|
{
|
|
return ParameterExceptionField::SINGLE_HEADER;
|
|
}
|
|
else if (hashCode == DEFAULT_ACTION_HASH)
|
|
{
|
|
return ParameterExceptionField::DEFAULT_ACTION;
|
|
}
|
|
else if (hashCode == RULE_ACTION_HASH)
|
|
{
|
|
return ParameterExceptionField::RULE_ACTION;
|
|
}
|
|
else if (hashCode == ENTITY_LIMIT_HASH)
|
|
{
|
|
return ParameterExceptionField::ENTITY_LIMIT;
|
|
}
|
|
else if (hashCode == OVERRIDE_ACTION_HASH)
|
|
{
|
|
return ParameterExceptionField::OVERRIDE_ACTION;
|
|
}
|
|
else if (hashCode == SCOPE_VALUE_HASH)
|
|
{
|
|
return ParameterExceptionField::SCOPE_VALUE;
|
|
}
|
|
else if (hashCode == RESOURCE_ARN_HASH)
|
|
{
|
|
return ParameterExceptionField::RESOURCE_ARN;
|
|
}
|
|
else if (hashCode == RESOURCE_TYPE_HASH)
|
|
{
|
|
return ParameterExceptionField::RESOURCE_TYPE;
|
|
}
|
|
else if (hashCode == TAGS_HASH)
|
|
{
|
|
return ParameterExceptionField::TAGS;
|
|
}
|
|
else if (hashCode == TAG_KEYS_HASH)
|
|
{
|
|
return ParameterExceptionField::TAG_KEYS;
|
|
}
|
|
else if (hashCode == METRIC_NAME_HASH)
|
|
{
|
|
return ParameterExceptionField::METRIC_NAME;
|
|
}
|
|
else if (hashCode == FIREWALL_MANAGER_STATEMENT_HASH)
|
|
{
|
|
return ParameterExceptionField::FIREWALL_MANAGER_STATEMENT;
|
|
}
|
|
else if (hashCode == FALLBACK_BEHAVIOR_HASH)
|
|
{
|
|
return ParameterExceptionField::FALLBACK_BEHAVIOR;
|
|
}
|
|
else if (hashCode == POSITION_HASH)
|
|
{
|
|
return ParameterExceptionField::POSITION;
|
|
}
|
|
else if (hashCode == FORWARDED_IP_CONFIG_HASH)
|
|
{
|
|
return ParameterExceptionField::FORWARDED_IP_CONFIG;
|
|
}
|
|
else if (hashCode == IP_SET_FORWARDED_IP_CONFIG_HASH)
|
|
{
|
|
return ParameterExceptionField::IP_SET_FORWARDED_IP_CONFIG;
|
|
}
|
|
else if (hashCode == HEADER_NAME_HASH)
|
|
{
|
|
return ParameterExceptionField::HEADER_NAME;
|
|
}
|
|
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
|
|
if(overflowContainer)
|
|
{
|
|
overflowContainer->StoreOverflow(hashCode, name);
|
|
return static_cast<ParameterExceptionField>(hashCode);
|
|
}
|
|
|
|
return ParameterExceptionField::NOT_SET;
|
|
}
|
|
|
|
Aws::String GetNameForParameterExceptionField(ParameterExceptionField enumValue)
|
|
{
|
|
switch(enumValue)
|
|
{
|
|
case ParameterExceptionField::WEB_ACL:
|
|
return "WEB_ACL";
|
|
case ParameterExceptionField::RULE_GROUP:
|
|
return "RULE_GROUP";
|
|
case ParameterExceptionField::REGEX_PATTERN_SET:
|
|
return "REGEX_PATTERN_SET";
|
|
case ParameterExceptionField::IP_SET:
|
|
return "IP_SET";
|
|
case ParameterExceptionField::MANAGED_RULE_SET:
|
|
return "MANAGED_RULE_SET";
|
|
case ParameterExceptionField::RULE:
|
|
return "RULE";
|
|
case ParameterExceptionField::EXCLUDED_RULE:
|
|
return "EXCLUDED_RULE";
|
|
case ParameterExceptionField::STATEMENT:
|
|
return "STATEMENT";
|
|
case ParameterExceptionField::BYTE_MATCH_STATEMENT:
|
|
return "BYTE_MATCH_STATEMENT";
|
|
case ParameterExceptionField::SQLI_MATCH_STATEMENT:
|
|
return "SQLI_MATCH_STATEMENT";
|
|
case ParameterExceptionField::XSS_MATCH_STATEMENT:
|
|
return "XSS_MATCH_STATEMENT";
|
|
case ParameterExceptionField::SIZE_CONSTRAINT_STATEMENT:
|
|
return "SIZE_CONSTRAINT_STATEMENT";
|
|
case ParameterExceptionField::GEO_MATCH_STATEMENT:
|
|
return "GEO_MATCH_STATEMENT";
|
|
case ParameterExceptionField::RATE_BASED_STATEMENT:
|
|
return "RATE_BASED_STATEMENT";
|
|
case ParameterExceptionField::RULE_GROUP_REFERENCE_STATEMENT:
|
|
return "RULE_GROUP_REFERENCE_STATEMENT";
|
|
case ParameterExceptionField::REGEX_PATTERN_REFERENCE_STATEMENT:
|
|
return "REGEX_PATTERN_REFERENCE_STATEMENT";
|
|
case ParameterExceptionField::IP_SET_REFERENCE_STATEMENT:
|
|
return "IP_SET_REFERENCE_STATEMENT";
|
|
case ParameterExceptionField::MANAGED_RULE_SET_STATEMENT:
|
|
return "MANAGED_RULE_SET_STATEMENT";
|
|
case ParameterExceptionField::AND_STATEMENT:
|
|
return "AND_STATEMENT";
|
|
case ParameterExceptionField::OR_STATEMENT:
|
|
return "OR_STATEMENT";
|
|
case ParameterExceptionField::NOT_STATEMENT:
|
|
return "NOT_STATEMENT";
|
|
case ParameterExceptionField::IP_ADDRESS:
|
|
return "IP_ADDRESS";
|
|
case ParameterExceptionField::IP_ADDRESS_VERSION:
|
|
return "IP_ADDRESS_VERSION";
|
|
case ParameterExceptionField::FIELD_TO_MATCH:
|
|
return "FIELD_TO_MATCH";
|
|
case ParameterExceptionField::TEXT_TRANSFORMATION:
|
|
return "TEXT_TRANSFORMATION";
|
|
case ParameterExceptionField::SINGLE_QUERY_ARGUMENT:
|
|
return "SINGLE_QUERY_ARGUMENT";
|
|
case ParameterExceptionField::SINGLE_HEADER:
|
|
return "SINGLE_HEADER";
|
|
case ParameterExceptionField::DEFAULT_ACTION:
|
|
return "DEFAULT_ACTION";
|
|
case ParameterExceptionField::RULE_ACTION:
|
|
return "RULE_ACTION";
|
|
case ParameterExceptionField::ENTITY_LIMIT:
|
|
return "ENTITY_LIMIT";
|
|
case ParameterExceptionField::OVERRIDE_ACTION:
|
|
return "OVERRIDE_ACTION";
|
|
case ParameterExceptionField::SCOPE_VALUE:
|
|
return "SCOPE_VALUE";
|
|
case ParameterExceptionField::RESOURCE_ARN:
|
|
return "RESOURCE_ARN";
|
|
case ParameterExceptionField::RESOURCE_TYPE:
|
|
return "RESOURCE_TYPE";
|
|
case ParameterExceptionField::TAGS:
|
|
return "TAGS";
|
|
case ParameterExceptionField::TAG_KEYS:
|
|
return "TAG_KEYS";
|
|
case ParameterExceptionField::METRIC_NAME:
|
|
return "METRIC_NAME";
|
|
case ParameterExceptionField::FIREWALL_MANAGER_STATEMENT:
|
|
return "FIREWALL_MANAGER_STATEMENT";
|
|
case ParameterExceptionField::FALLBACK_BEHAVIOR:
|
|
return "FALLBACK_BEHAVIOR";
|
|
case ParameterExceptionField::POSITION:
|
|
return "POSITION";
|
|
case ParameterExceptionField::FORWARDED_IP_CONFIG:
|
|
return "FORWARDED_IP_CONFIG";
|
|
case ParameterExceptionField::IP_SET_FORWARDED_IP_CONFIG:
|
|
return "IP_SET_FORWARDED_IP_CONFIG";
|
|
case ParameterExceptionField::HEADER_NAME:
|
|
return "HEADER_NAME";
|
|
default:
|
|
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
|
|
if(overflowContainer)
|
|
{
|
|
return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
|
|
}
|
|
|
|
return {};
|
|
}
|
|
}
|
|
|
|
} // namespace ParameterExceptionFieldMapper
|
|
} // namespace Model
|
|
} // namespace WAFV2
|
|
} // namespace Aws
|