in aws-cpp-sdk-ec2/source/EC2Errors.cpp [202:815]
static bool GetErrorForNameHelper0(int hashCode, AWSError<CoreErrors>& error)
{
if (hashCode == DRY_RUN_OPERATION_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::DRY_RUN_OPERATION), false);
return true;
}
else if (hashCode == INVALID_VPN_CONNECTION_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPN_CONNECTION_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == VOLUME_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VOLUME_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_SNAPSHOT__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SNAPSHOT__NOT_FOUND), false);
return true;
}
else if (hashCode == RESERVED_INSTANCES_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::RESERVED_INSTANCES_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_VPC_ENDPOINT_ID__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC_ENDPOINT_ID__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_ZONE__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ZONE__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_ROUTE__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ROUTE__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_NETWORK_INTERFACE_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_NETWORK_INTERFACE_ID__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_VPC__RANGE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC__RANGE), false);
return true;
}
else if (hashCode == NON_E_B_S_INSTANCE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::NON_E_B_S_INSTANCE), false);
return true;
}
else if (hashCode == INVALID_A_M_I_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_A_M_I_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_KEY_PAIR__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_KEY_PAIR__NOT_FOUND), false);
return true;
}
else if (hashCode == VPC_PEERING_CONNECTION_ALREADY_EXISTS_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VPC_PEERING_CONNECTION_ALREADY_EXISTS), false);
return true;
}
else if (hashCode == INVALID_VPC_ENDPOINT_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC_ENDPOINT_ID__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_VOLUME_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VOLUME_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_RESERVED_INSTANCES_OFFERING_ID_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_RESERVED_INSTANCES_OFFERING_ID), false);
return true;
}
else if (hashCode == INVALID_BLOCK_DEVICE_MAPPING_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_BLOCK_DEVICE_MAPPING), false);
return true;
}
else if (hashCode == INVALID_VOLUME_I_D__ZONE_MISMATCH_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VOLUME_I_D__ZONE_MISMATCH), false);
return true;
}
else if (hashCode == UNSUPPORTED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::UNSUPPORTED), false);
return true;
}
else if (hashCode == INVALID_KEY__FORMAT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_KEY__FORMAT), false);
return true;
}
else if (hashCode == INVALID_SPOT_FLEET_REQUEST_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SPOT_FLEET_REQUEST_ID__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_ADDRESS_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ADDRESS_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == ROUTE_ALREADY_EXISTS_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ROUTE_ALREADY_EXISTS), false);
return true;
}
else if (hashCode == INVALID_A_M_I_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_A_M_I_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_KEY_PAIR__FORMAT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_KEY_PAIR__FORMAT), false);
return true;
}
else if (hashCode == VPC_CIDR_CONFLICT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VPC_CIDR_CONFLICT), false);
return true;
}
else if (hashCode == INVALID_GROUP__RESERVED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GROUP__RESERVED), false);
return true;
}
else if (hashCode == LEGACY_SECURITY_GROUP_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::LEGACY_SECURITY_GROUP), false);
return true;
}
else if (hashCode == CANNOT_DELETE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::CANNOT_DELETE), false);
return true;
}
else if (hashCode == INVALID_I_P_ADDRESS__IN_USE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_I_P_ADDRESS__IN_USE), false);
return true;
}
else if (hashCode == INVALID_A_M_I_I_D__UNAVAILABLE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_A_M_I_I_D__UNAVAILABLE), false);
return true;
}
else if (hashCode == INVALID_FORMAT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_FORMAT), false);
return true;
}
else if (hashCode == INVALID_GROUP_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GROUP_ID__MALFORMED), false);
return true;
}
else if (hashCode == BUNDLING_IN_PROGRESS_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::BUNDLING_IN_PROGRESS), false);
return true;
}
else if (hashCode == INVALID_INSTANCE_TYPE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_INSTANCE_TYPE), false);
return true;
}
else if (hashCode == INVALID_PERMISSION__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_PERMISSION__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_ROUTE__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ROUTE__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_RESERVATION_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_RESERVATION_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_KEY_PAIR__DUPLICATE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_KEY_PAIR__DUPLICATE), false);
return true;
}
else if (hashCode == ROUTE_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ROUTE_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_SECURITY__REQUEST_HAS_EXPIRED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SECURITY__REQUEST_HAS_EXPIRED), false);
return true;
}
else if (hashCode == INVALID_SPOT_INSTANCE_REQUEST_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SPOT_INSTANCE_REQUEST_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_VPC_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == ROUTE_TABLE_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ROUTE_TABLE_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_ATTACHMENT_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ATTACHMENT_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_PERMISSION__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_PERMISSION__MALFORMED), false);
return true;
}
else if (hashCode == VOLUME_IN_USE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VOLUME_IN_USE), false);
return true;
}
else if (hashCode == ACTIVE_VPC_PEERING_CONNECTION_PER_VPC_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ACTIVE_VPC_PEERING_CONNECTION_PER_VPC_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_VOLUME__ZONE_MISMATCH_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VOLUME__ZONE_MISMATCH), false);
return true;
}
else if (hashCode == INVALID_DHCP_OPTION_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_DHCP_OPTION_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == PENDING_SNAPSHOT_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::PENDING_SNAPSHOT_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_PREFIX_LIST_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_PREFIX_LIST_ID__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_VPN_CONNECTION_I_D_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPN_CONNECTION_I_D), false);
return true;
}
else if (hashCode == INVALID_USER_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_USER_I_D__MALFORMED), false);
return true;
}
else if (hashCode == ADDRESS_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ADDRESS_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_GROUP__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GROUP__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_I_D_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_I_D), false);
return true;
}
else if (hashCode == VOLUME_TYPE_NOT_AVAILABLE_IN_ZONE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VOLUME_TYPE_NOT_AVAILABLE_IN_ZONE), false);
return true;
}
else if (hashCode == INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET), false);
return true;
}
else if (hashCode == DISK_IMAGE_SIZE_TOO_LARGE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::DISK_IMAGE_SIZE_TOO_LARGE), false);
return true;
}
else if (hashCode == INVALID_A_M_I_ATTRIBUTE_ITEM_VALUE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_A_M_I_ATTRIBUTE_ITEM_VALUE), false);
return true;
}
else if (hashCode == INVALID_GROUP__IN_USE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GROUP__IN_USE), false);
return true;
}
else if (hashCode == INVALID_SPOT_DATAFEED__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SPOT_DATAFEED__NOT_FOUND), false);
return true;
}
else if (hashCode == INSUFFICIENT_RESERVED_INSTANCES_CAPACITY_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INSUFFICIENT_RESERVED_INSTANCES_CAPACITY), false);
return true;
}
else if (hashCode == MAX_I_O_P_S_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::MAX_I_O_P_S_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == RESOURCE_COUNT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::RESOURCE_COUNT_EXCEEDED), false);
return true;
}
else if (hashCode == INCORRECT_STATE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INCORRECT_STATE), false);
return true;
}
else if (hashCode == NETWORK_ACL_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::NETWORK_ACL_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_RESERVED_INSTANCES_ID_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_RESERVED_INSTANCES_ID), false);
return true;
}
else if (hashCode == UNSUPPORTED_OPERATION_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::UNSUPPORTED_OPERATION), false);
return true;
}
else if (hashCode == INVALID_REQUEST_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_REQUEST), false);
return true;
}
else if (hashCode == VPC_ENDPOINT_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VPC_ENDPOINT_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_ROUTE_TABLE_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ROUTE_TABLE_ID__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_STATE_TRANSITION_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_STATE_TRANSITION), false);
return true;
}
else if (hashCode == INVALID_VPC_PEERING_CONNECTION_ID__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC_PEERING_CONNECTION_ID__MALFORMED), false);
return true;
}
else if (hashCode == PRIVATE_IP_ADDRESS_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::PRIVATE_IP_ADDRESS_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == VPC_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VPC_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_PERMISSION__DUPLICATE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_PERMISSION__DUPLICATE), false);
return true;
}
else if (hashCode == CUSTOMER_GATEWAY_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::CUSTOMER_GATEWAY_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INSTANCE_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INSTANCE_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INTERNET_GATEWAY_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INTERNET_GATEWAY_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == CONCURRENT_SNAPSHOT_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::CONCURRENT_SNAPSHOT_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == SECURITY_GROUPS_PER_INSTANCE_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::SECURITY_GROUPS_PER_INSTANCE_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == V_P_C_RESOURCE_NOT_SPECIFIED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::V_P_C_RESOURCE_NOT_SPECIFIED), false);
return true;
}
else if (hashCode == INVALID_SNAPSHOT__IN_USE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SNAPSHOT__IN_USE), false);
return true;
}
else if (hashCode == UNKNOWN_VOLUME_TYPE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::UNKNOWN_VOLUME_TYPE), false);
return true;
}
else if (hashCode == SECURITY_GROUP_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::SECURITY_GROUP_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_SUBNET_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SUBNET_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == GATEWAY__NOT_ATTACHED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::GATEWAY__NOT_ATTACHED), false);
return true;
}
else if (hashCode == INVALID_GROUP__DUPLICATE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GROUP__DUPLICATE), false);
return true;
}
else if (hashCode == ENCRYPTED_VOLUMES_NOT_SUPPORTED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::ENCRYPTED_VOLUMES_NOT_SUPPORTED), false);
return true;
}
else if (hashCode == INVALID_ROUTE_TABLE_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ROUTE_TABLE_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_SECURITY_GROUP_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SECURITY_GROUP_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_PLACEMENT_GROUP__UNKNOWN_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_PLACEMENT_GROUP__UNKNOWN), false);
return true;
}
else if (hashCode == INVALID_INSTANCE_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_INSTANCE_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INSTANCE_ALREADY_LINKED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INSTANCE_ALREADY_LINKED), false);
return true;
}
else if (hashCode == INVALID_ATTACHMENT__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ATTACHMENT__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_CUSTOMER_GATEWAY__DUPLICATE_IP_ADDRESS_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_CUSTOMER_GATEWAY__DUPLICATE_IP_ADDRESS), false);
return true;
}
else if (hashCode == INVALID_SUBNET__CONFLICT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SUBNET__CONFLICT), false);
return true;
}
else if (hashCode == INVALID_INPUT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_INPUT), false);
return true;
}
else if (hashCode == INVALID_INSTANCE_ATTRIBUTE_VALUE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_INSTANCE_ATTRIBUTE_VALUE), false);
return true;
}
else if (hashCode == REQUEST_RESOURCE_COUNT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::REQUEST_RESOURCE_COUNT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_ASSOCIATION_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ASSOCIATION_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_DEVICE__IN_USE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_DEVICE__IN_USE), false);
return true;
}
else if (hashCode == INVALID_CONVERSION_TASK_ID_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_CONVERSION_TASK_ID), false);
return true;
}
else if (hashCode == MAX_SPOT_FLEET_REQUEST_COUNT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::MAX_SPOT_FLEET_REQUEST_COUNT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_ALLOCATION_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ALLOCATION_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_CUSTOMER_GATEWAY_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_CUSTOMER_GATEWAY_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_POLICY_DOCUMENT_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_POLICY_DOCUMENT), false);
return true;
}
else if (hashCode == INVALID_SPOT_FLEET_REQUEST_ID__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SPOT_FLEET_REQUEST_ID__NOT_FOUND), false);
return true;
}
else if (hashCode == INVALID_FLOW_LOG_ID__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_FLOW_LOG_ID__NOT_FOUND), false);
return true;
}
else if (hashCode == VPN_GATEWAY_ATTACHMENT_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::VPN_GATEWAY_ATTACHMENT_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == FILTER_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::FILTER_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_SNAPSHOT_I_D__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SNAPSHOT_I_D__MALFORMED), false);
return true;
}
else if (hashCode == INVALID_SPOT_FLEET_REQUEST_CONFIG_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_SPOT_FLEET_REQUEST_CONFIG), false);
return true;
}
else if (hashCode == SNAPSHOT_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::SNAPSHOT_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_VPC_STATE_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_VPC_STATE), false);
return true;
}
else if (hashCode == INVALID_GATEWAY_I_D__NOT_FOUND_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_GATEWAY_I_D__NOT_FOUND), false);
return true;
}
else if (hashCode == SECURITY_GROUPS_PER_INTERFACE_LIMIT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::SECURITY_GROUPS_PER_INTERFACE_LIMIT_EXCEEDED), false);
return true;
}
else if (hashCode == MAX_SPOT_INSTANCE_COUNT_EXCEEDED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::MAX_SPOT_INSTANCE_COUNT_EXCEEDED), false);
return true;
}
else if (hashCode == INVALID_ADDRESS__MALFORMED_HASH)
{
error = AWSError<CoreErrors>(static_cast<CoreErrors>(EC2Errors::INVALID_ADDRESS__MALFORMED), false);
return true;
}
return false;
}