1 /** 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * SPDX-License-Identifier: Apache-2.0. 4 */ 5 6 #include <aws/waf/model/GeoMatchConstraintValue.h> 7 #include <aws/core/utils/HashingUtils.h> 8 #include <aws/core/Globals.h> 9 #include <aws/core/utils/EnumParseOverflowContainer.h> 10 11 using namespace Aws::Utils; 12 13 14 namespace Aws 15 { 16 namespace WAF 17 { 18 namespace Model 19 { 20 namespace GeoMatchConstraintValueMapper 21 { 22 23 static const int AF_HASH = HashingUtils::HashString("AF"); 24 static const int AX_HASH = HashingUtils::HashString("AX"); 25 static const int AL_HASH = HashingUtils::HashString("AL"); 26 static const int DZ_HASH = HashingUtils::HashString("DZ"); 27 static const int AS_HASH = HashingUtils::HashString("AS"); 28 static const int AD_HASH = HashingUtils::HashString("AD"); 29 static const int AO_HASH = HashingUtils::HashString("AO"); 30 static const int AI_HASH = HashingUtils::HashString("AI"); 31 static const int AQ_HASH = HashingUtils::HashString("AQ"); 32 static const int AG_HASH = HashingUtils::HashString("AG"); 33 static const int AR_HASH = HashingUtils::HashString("AR"); 34 static const int AM_HASH = HashingUtils::HashString("AM"); 35 static const int AW_HASH = HashingUtils::HashString("AW"); 36 static const int AU_HASH = HashingUtils::HashString("AU"); 37 static const int AT_HASH = HashingUtils::HashString("AT"); 38 static const int AZ_HASH = HashingUtils::HashString("AZ"); 39 static const int BS_HASH = HashingUtils::HashString("BS"); 40 static const int BH_HASH = HashingUtils::HashString("BH"); 41 static const int BD_HASH = HashingUtils::HashString("BD"); 42 static const int BB_HASH = HashingUtils::HashString("BB"); 43 static const int BY_HASH = HashingUtils::HashString("BY"); 44 static const int BE_HASH = HashingUtils::HashString("BE"); 45 static const int BZ_HASH = HashingUtils::HashString("BZ"); 46 static const int BJ_HASH = HashingUtils::HashString("BJ"); 47 static const int BM_HASH = HashingUtils::HashString("BM"); 48 static const int BT_HASH = HashingUtils::HashString("BT"); 49 static const int BO_HASH = HashingUtils::HashString("BO"); 50 static const int BQ_HASH = HashingUtils::HashString("BQ"); 51 static const int BA_HASH = HashingUtils::HashString("BA"); 52 static const int BW_HASH = HashingUtils::HashString("BW"); 53 static const int BV_HASH = HashingUtils::HashString("BV"); 54 static const int BR_HASH = HashingUtils::HashString("BR"); 55 static const int IO_HASH = HashingUtils::HashString("IO"); 56 static const int BN_HASH = HashingUtils::HashString("BN"); 57 static const int BG_HASH = HashingUtils::HashString("BG"); 58 static const int BF_HASH = HashingUtils::HashString("BF"); 59 static const int BI_HASH = HashingUtils::HashString("BI"); 60 static const int KH_HASH = HashingUtils::HashString("KH"); 61 static const int CM_HASH = HashingUtils::HashString("CM"); 62 static const int CA_HASH = HashingUtils::HashString("CA"); 63 static const int CV_HASH = HashingUtils::HashString("CV"); 64 static const int KY_HASH = HashingUtils::HashString("KY"); 65 static const int CF_HASH = HashingUtils::HashString("CF"); 66 static const int TD_HASH = HashingUtils::HashString("TD"); 67 static const int CL_HASH = HashingUtils::HashString("CL"); 68 static const int CN_HASH = HashingUtils::HashString("CN"); 69 static const int CX_HASH = HashingUtils::HashString("CX"); 70 static const int CC_HASH = HashingUtils::HashString("CC"); 71 static const int CO_HASH = HashingUtils::HashString("CO"); 72 static const int KM_HASH = HashingUtils::HashString("KM"); 73 static const int CG_HASH = HashingUtils::HashString("CG"); 74 static const int CD_HASH = HashingUtils::HashString("CD"); 75 static const int CK_HASH = HashingUtils::HashString("CK"); 76 static const int CR_HASH = HashingUtils::HashString("CR"); 77 static const int CI_HASH = HashingUtils::HashString("CI"); 78 static const int HR_HASH = HashingUtils::HashString("HR"); 79 static const int CU_HASH = HashingUtils::HashString("CU"); 80 static const int CW_HASH = HashingUtils::HashString("CW"); 81 static const int CY_HASH = HashingUtils::HashString("CY"); 82 static const int CZ_HASH = HashingUtils::HashString("CZ"); 83 static const int DK_HASH = HashingUtils::HashString("DK"); 84 static const int DJ_HASH = HashingUtils::HashString("DJ"); 85 static const int DM_HASH = HashingUtils::HashString("DM"); 86 static const int DO_HASH = HashingUtils::HashString("DO"); 87 static const int EC_HASH = HashingUtils::HashString("EC"); 88 static const int EG_HASH = HashingUtils::HashString("EG"); 89 static const int SV_HASH = HashingUtils::HashString("SV"); 90 static const int GQ_HASH = HashingUtils::HashString("GQ"); 91 static const int ER_HASH = HashingUtils::HashString("ER"); 92 static const int EE_HASH = HashingUtils::HashString("EE"); 93 static const int ET_HASH = HashingUtils::HashString("ET"); 94 static const int FK_HASH = HashingUtils::HashString("FK"); 95 static const int FO_HASH = HashingUtils::HashString("FO"); 96 static const int FJ_HASH = HashingUtils::HashString("FJ"); 97 static const int FI_HASH = HashingUtils::HashString("FI"); 98 static const int FR_HASH = HashingUtils::HashString("FR"); 99 static const int GF_HASH = HashingUtils::HashString("GF"); 100 static const int PF_HASH = HashingUtils::HashString("PF"); 101 static const int TF_HASH = HashingUtils::HashString("TF"); 102 static const int GA_HASH = HashingUtils::HashString("GA"); 103 static const int GM_HASH = HashingUtils::HashString("GM"); 104 static const int GE_HASH = HashingUtils::HashString("GE"); 105 static const int DE_HASH = HashingUtils::HashString("DE"); 106 static const int GH_HASH = HashingUtils::HashString("GH"); 107 static const int GI_HASH = HashingUtils::HashString("GI"); 108 static const int GR_HASH = HashingUtils::HashString("GR"); 109 static const int GL_HASH = HashingUtils::HashString("GL"); 110 static const int GD_HASH = HashingUtils::HashString("GD"); 111 static const int GP_HASH = HashingUtils::HashString("GP"); 112 static const int GU_HASH = HashingUtils::HashString("GU"); 113 static const int GT_HASH = HashingUtils::HashString("GT"); 114 static const int GG_HASH = HashingUtils::HashString("GG"); 115 static const int GN_HASH = HashingUtils::HashString("GN"); 116 static const int GW_HASH = HashingUtils::HashString("GW"); 117 static const int GY_HASH = HashingUtils::HashString("GY"); 118 static const int HT_HASH = HashingUtils::HashString("HT"); 119 static const int HM_HASH = HashingUtils::HashString("HM"); 120 static const int VA_HASH = HashingUtils::HashString("VA"); 121 static const int HN_HASH = HashingUtils::HashString("HN"); 122 static const int HK_HASH = HashingUtils::HashString("HK"); 123 static const int HU_HASH = HashingUtils::HashString("HU"); 124 static const int IS_HASH = HashingUtils::HashString("IS"); 125 static const int IN_HASH = HashingUtils::HashString("IN"); 126 static const int ID_HASH = HashingUtils::HashString("ID"); 127 static const int IR_HASH = HashingUtils::HashString("IR"); 128 static const int IQ_HASH = HashingUtils::HashString("IQ"); 129 static const int IE_HASH = HashingUtils::HashString("IE"); 130 static const int IM_HASH = HashingUtils::HashString("IM"); 131 static const int IL_HASH = HashingUtils::HashString("IL"); 132 static const int IT_HASH = HashingUtils::HashString("IT"); 133 static const int JM_HASH = HashingUtils::HashString("JM"); 134 static const int JP_HASH = HashingUtils::HashString("JP"); 135 static const int JE_HASH = HashingUtils::HashString("JE"); 136 static const int JO_HASH = HashingUtils::HashString("JO"); 137 static const int KZ_HASH = HashingUtils::HashString("KZ"); 138 static const int KE_HASH = HashingUtils::HashString("KE"); 139 static const int KI_HASH = HashingUtils::HashString("KI"); 140 static const int KP_HASH = HashingUtils::HashString("KP"); 141 static const int KR_HASH = HashingUtils::HashString("KR"); 142 static const int KW_HASH = HashingUtils::HashString("KW"); 143 static const int KG_HASH = HashingUtils::HashString("KG"); 144 static const int LA_HASH = HashingUtils::HashString("LA"); 145 static const int LV_HASH = HashingUtils::HashString("LV"); 146 static const int LB_HASH = HashingUtils::HashString("LB"); 147 static const int LS_HASH = HashingUtils::HashString("LS"); 148 static const int LR_HASH = HashingUtils::HashString("LR"); 149 static const int LY_HASH = HashingUtils::HashString("LY"); 150 static const int LI_HASH = HashingUtils::HashString("LI"); 151 static const int LT_HASH = HashingUtils::HashString("LT"); 152 static const int LU_HASH = HashingUtils::HashString("LU"); 153 static const int MO_HASH = HashingUtils::HashString("MO"); 154 static const int MK_HASH = HashingUtils::HashString("MK"); 155 static const int MG_HASH = HashingUtils::HashString("MG"); 156 static const int MW_HASH = HashingUtils::HashString("MW"); 157 static const int MY_HASH = HashingUtils::HashString("MY"); 158 static const int MV_HASH = HashingUtils::HashString("MV"); 159 static const int ML_HASH = HashingUtils::HashString("ML"); 160 static const int MT_HASH = HashingUtils::HashString("MT"); 161 static const int MH_HASH = HashingUtils::HashString("MH"); 162 static const int MQ_HASH = HashingUtils::HashString("MQ"); 163 static const int MR_HASH = HashingUtils::HashString("MR"); 164 static const int MU_HASH = HashingUtils::HashString("MU"); 165 static const int YT_HASH = HashingUtils::HashString("YT"); 166 static const int MX_HASH = HashingUtils::HashString("MX"); 167 static const int FM_HASH = HashingUtils::HashString("FM"); 168 static const int MD_HASH = HashingUtils::HashString("MD"); 169 static const int MC_HASH = HashingUtils::HashString("MC"); 170 static const int MN_HASH = HashingUtils::HashString("MN"); 171 static const int ME_HASH = HashingUtils::HashString("ME"); 172 static const int MS_HASH = HashingUtils::HashString("MS"); 173 static const int MA_HASH = HashingUtils::HashString("MA"); 174 static const int MZ_HASH = HashingUtils::HashString("MZ"); 175 static const int MM_HASH = HashingUtils::HashString("MM"); 176 static const int NA_HASH = HashingUtils::HashString("NA"); 177 static const int NR_HASH = HashingUtils::HashString("NR"); 178 static const int NP_HASH = HashingUtils::HashString("NP"); 179 static const int NL_HASH = HashingUtils::HashString("NL"); 180 static const int NC_HASH = HashingUtils::HashString("NC"); 181 static const int NZ_HASH = HashingUtils::HashString("NZ"); 182 static const int NI_HASH = HashingUtils::HashString("NI"); 183 static const int NE_HASH = HashingUtils::HashString("NE"); 184 static const int NG_HASH = HashingUtils::HashString("NG"); 185 static const int NU_HASH = HashingUtils::HashString("NU"); 186 static const int NF_HASH = HashingUtils::HashString("NF"); 187 static const int MP_HASH = HashingUtils::HashString("MP"); 188 static const int NO_HASH = HashingUtils::HashString("NO"); 189 static const int OM_HASH = HashingUtils::HashString("OM"); 190 static const int PK_HASH = HashingUtils::HashString("PK"); 191 static const int PW_HASH = HashingUtils::HashString("PW"); 192 static const int PS_HASH = HashingUtils::HashString("PS"); 193 static const int PA_HASH = HashingUtils::HashString("PA"); 194 static const int PG_HASH = HashingUtils::HashString("PG"); 195 static const int PY_HASH = HashingUtils::HashString("PY"); 196 static const int PE_HASH = HashingUtils::HashString("PE"); 197 static const int PH_HASH = HashingUtils::HashString("PH"); 198 static const int PN_HASH = HashingUtils::HashString("PN"); 199 static const int PL_HASH = HashingUtils::HashString("PL"); 200 static const int PT_HASH = HashingUtils::HashString("PT"); 201 static const int PR_HASH = HashingUtils::HashString("PR"); 202 static const int QA_HASH = HashingUtils::HashString("QA"); 203 static const int RE_HASH = HashingUtils::HashString("RE"); 204 static const int RO_HASH = HashingUtils::HashString("RO"); 205 static const int RU_HASH = HashingUtils::HashString("RU"); 206 static const int RW_HASH = HashingUtils::HashString("RW"); 207 static const int BL_HASH = HashingUtils::HashString("BL"); 208 static const int SH_HASH = HashingUtils::HashString("SH"); 209 static const int KN_HASH = HashingUtils::HashString("KN"); 210 static const int LC_HASH = HashingUtils::HashString("LC"); 211 static const int MF_HASH = HashingUtils::HashString("MF"); 212 static const int PM_HASH = HashingUtils::HashString("PM"); 213 static const int VC_HASH = HashingUtils::HashString("VC"); 214 static const int WS_HASH = HashingUtils::HashString("WS"); 215 static const int SM_HASH = HashingUtils::HashString("SM"); 216 static const int ST_HASH = HashingUtils::HashString("ST"); 217 static const int SA_HASH = HashingUtils::HashString("SA"); 218 static const int SN_HASH = HashingUtils::HashString("SN"); 219 static const int RS_HASH = HashingUtils::HashString("RS"); 220 static const int SC_HASH = HashingUtils::HashString("SC"); 221 static const int SL_HASH = HashingUtils::HashString("SL"); 222 static const int SG_HASH = HashingUtils::HashString("SG"); 223 static const int SX_HASH = HashingUtils::HashString("SX"); 224 static const int SK_HASH = HashingUtils::HashString("SK"); 225 static const int SI_HASH = HashingUtils::HashString("SI"); 226 static const int SB_HASH = HashingUtils::HashString("SB"); 227 static const int SO_HASH = HashingUtils::HashString("SO"); 228 static const int ZA_HASH = HashingUtils::HashString("ZA"); 229 static const int GS_HASH = HashingUtils::HashString("GS"); 230 static const int SS_HASH = HashingUtils::HashString("SS"); 231 static const int ES_HASH = HashingUtils::HashString("ES"); 232 static const int LK_HASH = HashingUtils::HashString("LK"); 233 static const int SD_HASH = HashingUtils::HashString("SD"); 234 static const int SR_HASH = HashingUtils::HashString("SR"); 235 static const int SJ_HASH = HashingUtils::HashString("SJ"); 236 static const int SZ_HASH = HashingUtils::HashString("SZ"); 237 static const int SE_HASH = HashingUtils::HashString("SE"); 238 static const int CH_HASH = HashingUtils::HashString("CH"); 239 static const int SY_HASH = HashingUtils::HashString("SY"); 240 static const int TW_HASH = HashingUtils::HashString("TW"); 241 static const int TJ_HASH = HashingUtils::HashString("TJ"); 242 static const int TZ_HASH = HashingUtils::HashString("TZ"); 243 static const int TH_HASH = HashingUtils::HashString("TH"); 244 static const int TL_HASH = HashingUtils::HashString("TL"); 245 static const int TG_HASH = HashingUtils::HashString("TG"); 246 static const int TK_HASH = HashingUtils::HashString("TK"); 247 static const int TO_HASH = HashingUtils::HashString("TO"); 248 static const int TT_HASH = HashingUtils::HashString("TT"); 249 static const int TN_HASH = HashingUtils::HashString("TN"); 250 static const int TR_HASH = HashingUtils::HashString("TR"); 251 static const int TM_HASH = HashingUtils::HashString("TM"); 252 static const int TC_HASH = HashingUtils::HashString("TC"); 253 static const int TV_HASH = HashingUtils::HashString("TV"); 254 static const int UG_HASH = HashingUtils::HashString("UG"); 255 static const int UA_HASH = HashingUtils::HashString("UA"); 256 static const int AE_HASH = HashingUtils::HashString("AE"); 257 static const int GB_HASH = HashingUtils::HashString("GB"); 258 static const int US_HASH = HashingUtils::HashString("US"); 259 static const int UM_HASH = HashingUtils::HashString("UM"); 260 static const int UY_HASH = HashingUtils::HashString("UY"); 261 static const int UZ_HASH = HashingUtils::HashString("UZ"); 262 static const int VU_HASH = HashingUtils::HashString("VU"); 263 static const int VE_HASH = HashingUtils::HashString("VE"); 264 static const int VN_HASH = HashingUtils::HashString("VN"); 265 static const int VG_HASH = HashingUtils::HashString("VG"); 266 static const int VI_HASH = HashingUtils::HashString("VI"); 267 static const int WF_HASH = HashingUtils::HashString("WF"); 268 static const int EH_HASH = HashingUtils::HashString("EH"); 269 static const int YE_HASH = HashingUtils::HashString("YE"); 270 static const int ZM_HASH = HashingUtils::HashString("ZM"); 271 static const int ZW_HASH = HashingUtils::HashString("ZW"); 272 273 /* 274 The if-else chains in this file are converted into a jump table by the compiler, 275 which allows constant time lookup. The chain has been broken into helper functions 276 because MSVC has a maximum of 122 chained if-else blocks. 277 */ GetEnumForNameHelper0(int hashCode,GeoMatchConstraintValue & enumValue)278 static bool GetEnumForNameHelper0(int hashCode, GeoMatchConstraintValue& enumValue) 279 { 280 if (hashCode == AF_HASH) 281 { 282 enumValue = GeoMatchConstraintValue::AF; 283 return true; 284 } 285 else if (hashCode == AX_HASH) 286 { 287 enumValue = GeoMatchConstraintValue::AX; 288 return true; 289 } 290 else if (hashCode == AL_HASH) 291 { 292 enumValue = GeoMatchConstraintValue::AL; 293 return true; 294 } 295 else if (hashCode == DZ_HASH) 296 { 297 enumValue = GeoMatchConstraintValue::DZ; 298 return true; 299 } 300 else if (hashCode == AS_HASH) 301 { 302 enumValue = GeoMatchConstraintValue::AS; 303 return true; 304 } 305 else if (hashCode == AD_HASH) 306 { 307 enumValue = GeoMatchConstraintValue::AD; 308 return true; 309 } 310 else if (hashCode == AO_HASH) 311 { 312 enumValue = GeoMatchConstraintValue::AO; 313 return true; 314 } 315 else if (hashCode == AI_HASH) 316 { 317 enumValue = GeoMatchConstraintValue::AI; 318 return true; 319 } 320 else if (hashCode == AQ_HASH) 321 { 322 enumValue = GeoMatchConstraintValue::AQ; 323 return true; 324 } 325 else if (hashCode == AG_HASH) 326 { 327 enumValue = GeoMatchConstraintValue::AG; 328 return true; 329 } 330 else if (hashCode == AR_HASH) 331 { 332 enumValue = GeoMatchConstraintValue::AR; 333 return true; 334 } 335 else if (hashCode == AM_HASH) 336 { 337 enumValue = GeoMatchConstraintValue::AM; 338 return true; 339 } 340 else if (hashCode == AW_HASH) 341 { 342 enumValue = GeoMatchConstraintValue::AW; 343 return true; 344 } 345 else if (hashCode == AU_HASH) 346 { 347 enumValue = GeoMatchConstraintValue::AU; 348 return true; 349 } 350 else if (hashCode == AT_HASH) 351 { 352 enumValue = GeoMatchConstraintValue::AT; 353 return true; 354 } 355 else if (hashCode == AZ_HASH) 356 { 357 enumValue = GeoMatchConstraintValue::AZ; 358 return true; 359 } 360 else if (hashCode == BS_HASH) 361 { 362 enumValue = GeoMatchConstraintValue::BS; 363 return true; 364 } 365 else if (hashCode == BH_HASH) 366 { 367 enumValue = GeoMatchConstraintValue::BH; 368 return true; 369 } 370 else if (hashCode == BD_HASH) 371 { 372 enumValue = GeoMatchConstraintValue::BD; 373 return true; 374 } 375 else if (hashCode == BB_HASH) 376 { 377 enumValue = GeoMatchConstraintValue::BB; 378 return true; 379 } 380 else if (hashCode == BY_HASH) 381 { 382 enumValue = GeoMatchConstraintValue::BY; 383 return true; 384 } 385 else if (hashCode == BE_HASH) 386 { 387 enumValue = GeoMatchConstraintValue::BE; 388 return true; 389 } 390 else if (hashCode == BZ_HASH) 391 { 392 enumValue = GeoMatchConstraintValue::BZ; 393 return true; 394 } 395 else if (hashCode == BJ_HASH) 396 { 397 enumValue = GeoMatchConstraintValue::BJ; 398 return true; 399 } 400 else if (hashCode == BM_HASH) 401 { 402 enumValue = GeoMatchConstraintValue::BM; 403 return true; 404 } 405 else if (hashCode == BT_HASH) 406 { 407 enumValue = GeoMatchConstraintValue::BT; 408 return true; 409 } 410 else if (hashCode == BO_HASH) 411 { 412 enumValue = GeoMatchConstraintValue::BO; 413 return true; 414 } 415 else if (hashCode == BQ_HASH) 416 { 417 enumValue = GeoMatchConstraintValue::BQ; 418 return true; 419 } 420 else if (hashCode == BA_HASH) 421 { 422 enumValue = GeoMatchConstraintValue::BA; 423 return true; 424 } 425 else if (hashCode == BW_HASH) 426 { 427 enumValue = GeoMatchConstraintValue::BW; 428 return true; 429 } 430 else if (hashCode == BV_HASH) 431 { 432 enumValue = GeoMatchConstraintValue::BV; 433 return true; 434 } 435 else if (hashCode == BR_HASH) 436 { 437 enumValue = GeoMatchConstraintValue::BR; 438 return true; 439 } 440 else if (hashCode == IO_HASH) 441 { 442 enumValue = GeoMatchConstraintValue::IO; 443 return true; 444 } 445 else if (hashCode == BN_HASH) 446 { 447 enumValue = GeoMatchConstraintValue::BN; 448 return true; 449 } 450 else if (hashCode == BG_HASH) 451 { 452 enumValue = GeoMatchConstraintValue::BG; 453 return true; 454 } 455 else if (hashCode == BF_HASH) 456 { 457 enumValue = GeoMatchConstraintValue::BF; 458 return true; 459 } 460 else if (hashCode == BI_HASH) 461 { 462 enumValue = GeoMatchConstraintValue::BI; 463 return true; 464 } 465 else if (hashCode == KH_HASH) 466 { 467 enumValue = GeoMatchConstraintValue::KH; 468 return true; 469 } 470 else if (hashCode == CM_HASH) 471 { 472 enumValue = GeoMatchConstraintValue::CM; 473 return true; 474 } 475 else if (hashCode == CA_HASH) 476 { 477 enumValue = GeoMatchConstraintValue::CA; 478 return true; 479 } 480 else if (hashCode == CV_HASH) 481 { 482 enumValue = GeoMatchConstraintValue::CV; 483 return true; 484 } 485 else if (hashCode == KY_HASH) 486 { 487 enumValue = GeoMatchConstraintValue::KY; 488 return true; 489 } 490 else if (hashCode == CF_HASH) 491 { 492 enumValue = GeoMatchConstraintValue::CF; 493 return true; 494 } 495 else if (hashCode == TD_HASH) 496 { 497 enumValue = GeoMatchConstraintValue::TD; 498 return true; 499 } 500 else if (hashCode == CL_HASH) 501 { 502 enumValue = GeoMatchConstraintValue::CL; 503 return true; 504 } 505 else if (hashCode == CN_HASH) 506 { 507 enumValue = GeoMatchConstraintValue::CN; 508 return true; 509 } 510 else if (hashCode == CX_HASH) 511 { 512 enumValue = GeoMatchConstraintValue::CX; 513 return true; 514 } 515 else if (hashCode == CC_HASH) 516 { 517 enumValue = GeoMatchConstraintValue::CC; 518 return true; 519 } 520 else if (hashCode == CO_HASH) 521 { 522 enumValue = GeoMatchConstraintValue::CO; 523 return true; 524 } 525 else if (hashCode == KM_HASH) 526 { 527 enumValue = GeoMatchConstraintValue::KM; 528 return true; 529 } 530 else if (hashCode == CG_HASH) 531 { 532 enumValue = GeoMatchConstraintValue::CG; 533 return true; 534 } 535 else if (hashCode == CD_HASH) 536 { 537 enumValue = GeoMatchConstraintValue::CD; 538 return true; 539 } 540 else if (hashCode == CK_HASH) 541 { 542 enumValue = GeoMatchConstraintValue::CK; 543 return true; 544 } 545 else if (hashCode == CR_HASH) 546 { 547 enumValue = GeoMatchConstraintValue::CR; 548 return true; 549 } 550 else if (hashCode == CI_HASH) 551 { 552 enumValue = GeoMatchConstraintValue::CI; 553 return true; 554 } 555 else if (hashCode == HR_HASH) 556 { 557 enumValue = GeoMatchConstraintValue::HR; 558 return true; 559 } 560 else if (hashCode == CU_HASH) 561 { 562 enumValue = GeoMatchConstraintValue::CU; 563 return true; 564 } 565 else if (hashCode == CW_HASH) 566 { 567 enumValue = GeoMatchConstraintValue::CW; 568 return true; 569 } 570 else if (hashCode == CY_HASH) 571 { 572 enumValue = GeoMatchConstraintValue::CY; 573 return true; 574 } 575 else if (hashCode == CZ_HASH) 576 { 577 enumValue = GeoMatchConstraintValue::CZ; 578 return true; 579 } 580 else if (hashCode == DK_HASH) 581 { 582 enumValue = GeoMatchConstraintValue::DK; 583 return true; 584 } 585 else if (hashCode == DJ_HASH) 586 { 587 enumValue = GeoMatchConstraintValue::DJ; 588 return true; 589 } 590 else if (hashCode == DM_HASH) 591 { 592 enumValue = GeoMatchConstraintValue::DM; 593 return true; 594 } 595 else if (hashCode == DO_HASH) 596 { 597 enumValue = GeoMatchConstraintValue::DO; 598 return true; 599 } 600 else if (hashCode == EC_HASH) 601 { 602 enumValue = GeoMatchConstraintValue::EC; 603 return true; 604 } 605 else if (hashCode == EG_HASH) 606 { 607 enumValue = GeoMatchConstraintValue::EG; 608 return true; 609 } 610 else if (hashCode == SV_HASH) 611 { 612 enumValue = GeoMatchConstraintValue::SV; 613 return true; 614 } 615 else if (hashCode == GQ_HASH) 616 { 617 enumValue = GeoMatchConstraintValue::GQ; 618 return true; 619 } 620 else if (hashCode == ER_HASH) 621 { 622 enumValue = GeoMatchConstraintValue::ER; 623 return true; 624 } 625 else if (hashCode == EE_HASH) 626 { 627 enumValue = GeoMatchConstraintValue::EE; 628 return true; 629 } 630 else if (hashCode == ET_HASH) 631 { 632 enumValue = GeoMatchConstraintValue::ET; 633 return true; 634 } 635 else if (hashCode == FK_HASH) 636 { 637 enumValue = GeoMatchConstraintValue::FK; 638 return true; 639 } 640 else if (hashCode == FO_HASH) 641 { 642 enumValue = GeoMatchConstraintValue::FO; 643 return true; 644 } 645 else if (hashCode == FJ_HASH) 646 { 647 enumValue = GeoMatchConstraintValue::FJ; 648 return true; 649 } 650 else if (hashCode == FI_HASH) 651 { 652 enumValue = GeoMatchConstraintValue::FI; 653 return true; 654 } 655 else if (hashCode == FR_HASH) 656 { 657 enumValue = GeoMatchConstraintValue::FR; 658 return true; 659 } 660 else if (hashCode == GF_HASH) 661 { 662 enumValue = GeoMatchConstraintValue::GF; 663 return true; 664 } 665 else if (hashCode == PF_HASH) 666 { 667 enumValue = GeoMatchConstraintValue::PF; 668 return true; 669 } 670 else if (hashCode == TF_HASH) 671 { 672 enumValue = GeoMatchConstraintValue::TF; 673 return true; 674 } 675 else if (hashCode == GA_HASH) 676 { 677 enumValue = GeoMatchConstraintValue::GA; 678 return true; 679 } 680 else if (hashCode == GM_HASH) 681 { 682 enumValue = GeoMatchConstraintValue::GM; 683 return true; 684 } 685 else if (hashCode == GE_HASH) 686 { 687 enumValue = GeoMatchConstraintValue::GE; 688 return true; 689 } 690 else if (hashCode == DE_HASH) 691 { 692 enumValue = GeoMatchConstraintValue::DE; 693 return true; 694 } 695 else if (hashCode == GH_HASH) 696 { 697 enumValue = GeoMatchConstraintValue::GH; 698 return true; 699 } 700 else if (hashCode == GI_HASH) 701 { 702 enumValue = GeoMatchConstraintValue::GI; 703 return true; 704 } 705 else if (hashCode == GR_HASH) 706 { 707 enumValue = GeoMatchConstraintValue::GR; 708 return true; 709 } 710 else if (hashCode == GL_HASH) 711 { 712 enumValue = GeoMatchConstraintValue::GL; 713 return true; 714 } 715 else if (hashCode == GD_HASH) 716 { 717 enumValue = GeoMatchConstraintValue::GD; 718 return true; 719 } 720 else if (hashCode == GP_HASH) 721 { 722 enumValue = GeoMatchConstraintValue::GP; 723 return true; 724 } 725 else if (hashCode == GU_HASH) 726 { 727 enumValue = GeoMatchConstraintValue::GU; 728 return true; 729 } 730 else if (hashCode == GT_HASH) 731 { 732 enumValue = GeoMatchConstraintValue::GT; 733 return true; 734 } 735 else if (hashCode == GG_HASH) 736 { 737 enumValue = GeoMatchConstraintValue::GG; 738 return true; 739 } 740 else if (hashCode == GN_HASH) 741 { 742 enumValue = GeoMatchConstraintValue::GN; 743 return true; 744 } 745 else if (hashCode == GW_HASH) 746 { 747 enumValue = GeoMatchConstraintValue::GW; 748 return true; 749 } 750 else if (hashCode == GY_HASH) 751 { 752 enumValue = GeoMatchConstraintValue::GY; 753 return true; 754 } 755 else if (hashCode == HT_HASH) 756 { 757 enumValue = GeoMatchConstraintValue::HT; 758 return true; 759 } 760 else if (hashCode == HM_HASH) 761 { 762 enumValue = GeoMatchConstraintValue::HM; 763 return true; 764 } 765 else if (hashCode == VA_HASH) 766 { 767 enumValue = GeoMatchConstraintValue::VA; 768 return true; 769 } 770 else if (hashCode == HN_HASH) 771 { 772 enumValue = GeoMatchConstraintValue::HN; 773 return true; 774 } 775 else if (hashCode == HK_HASH) 776 { 777 enumValue = GeoMatchConstraintValue::HK; 778 return true; 779 } 780 else if (hashCode == HU_HASH) 781 { 782 enumValue = GeoMatchConstraintValue::HU; 783 return true; 784 } 785 else if (hashCode == IS_HASH) 786 { 787 enumValue = GeoMatchConstraintValue::IS; 788 return true; 789 } 790 else if (hashCode == IN_HASH) 791 { 792 enumValue = GeoMatchConstraintValue::IN; 793 return true; 794 } 795 else if (hashCode == ID_HASH) 796 { 797 enumValue = GeoMatchConstraintValue::ID; 798 return true; 799 } 800 else if (hashCode == IR_HASH) 801 { 802 enumValue = GeoMatchConstraintValue::IR; 803 return true; 804 } 805 else if (hashCode == IQ_HASH) 806 { 807 enumValue = GeoMatchConstraintValue::IQ; 808 return true; 809 } 810 else if (hashCode == IE_HASH) 811 { 812 enumValue = GeoMatchConstraintValue::IE; 813 return true; 814 } 815 else if (hashCode == IM_HASH) 816 { 817 enumValue = GeoMatchConstraintValue::IM; 818 return true; 819 } 820 else if (hashCode == IL_HASH) 821 { 822 enumValue = GeoMatchConstraintValue::IL; 823 return true; 824 } 825 else if (hashCode == IT_HASH) 826 { 827 enumValue = GeoMatchConstraintValue::IT; 828 return true; 829 } 830 else if (hashCode == JM_HASH) 831 { 832 enumValue = GeoMatchConstraintValue::JM; 833 return true; 834 } 835 else if (hashCode == JP_HASH) 836 { 837 enumValue = GeoMatchConstraintValue::JP; 838 return true; 839 } 840 else if (hashCode == JE_HASH) 841 { 842 enumValue = GeoMatchConstraintValue::JE; 843 return true; 844 } 845 else if (hashCode == JO_HASH) 846 { 847 enumValue = GeoMatchConstraintValue::JO; 848 return true; 849 } 850 else if (hashCode == KZ_HASH) 851 { 852 enumValue = GeoMatchConstraintValue::KZ; 853 return true; 854 } 855 else if (hashCode == KE_HASH) 856 { 857 enumValue = GeoMatchConstraintValue::KE; 858 return true; 859 } 860 else if (hashCode == KI_HASH) 861 { 862 enumValue = GeoMatchConstraintValue::KI; 863 return true; 864 } 865 else if (hashCode == KP_HASH) 866 { 867 enumValue = GeoMatchConstraintValue::KP; 868 return true; 869 } 870 else if (hashCode == KR_HASH) 871 { 872 enumValue = GeoMatchConstraintValue::KR; 873 return true; 874 } 875 else if (hashCode == KW_HASH) 876 { 877 enumValue = GeoMatchConstraintValue::KW; 878 return true; 879 } 880 else if (hashCode == KG_HASH) 881 { 882 enumValue = GeoMatchConstraintValue::KG; 883 return true; 884 } 885 else if (hashCode == LA_HASH) 886 { 887 enumValue = GeoMatchConstraintValue::LA; 888 return true; 889 } 890 return false; 891 } GetEnumForNameHelper1(int hashCode,GeoMatchConstraintValue & enumValue)892 static bool GetEnumForNameHelper1(int hashCode, GeoMatchConstraintValue& enumValue) 893 { 894 if (hashCode == LV_HASH) 895 { 896 enumValue = GeoMatchConstraintValue::LV; 897 return true; 898 } 899 else if (hashCode == LB_HASH) 900 { 901 enumValue = GeoMatchConstraintValue::LB; 902 return true; 903 } 904 else if (hashCode == LS_HASH) 905 { 906 enumValue = GeoMatchConstraintValue::LS; 907 return true; 908 } 909 else if (hashCode == LR_HASH) 910 { 911 enumValue = GeoMatchConstraintValue::LR; 912 return true; 913 } 914 else if (hashCode == LY_HASH) 915 { 916 enumValue = GeoMatchConstraintValue::LY; 917 return true; 918 } 919 else if (hashCode == LI_HASH) 920 { 921 enumValue = GeoMatchConstraintValue::LI; 922 return true; 923 } 924 else if (hashCode == LT_HASH) 925 { 926 enumValue = GeoMatchConstraintValue::LT; 927 return true; 928 } 929 else if (hashCode == LU_HASH) 930 { 931 enumValue = GeoMatchConstraintValue::LU; 932 return true; 933 } 934 else if (hashCode == MO_HASH) 935 { 936 enumValue = GeoMatchConstraintValue::MO; 937 return true; 938 } 939 else if (hashCode == MK_HASH) 940 { 941 enumValue = GeoMatchConstraintValue::MK; 942 return true; 943 } 944 else if (hashCode == MG_HASH) 945 { 946 enumValue = GeoMatchConstraintValue::MG; 947 return true; 948 } 949 else if (hashCode == MW_HASH) 950 { 951 enumValue = GeoMatchConstraintValue::MW; 952 return true; 953 } 954 else if (hashCode == MY_HASH) 955 { 956 enumValue = GeoMatchConstraintValue::MY; 957 return true; 958 } 959 else if (hashCode == MV_HASH) 960 { 961 enumValue = GeoMatchConstraintValue::MV; 962 return true; 963 } 964 else if (hashCode == ML_HASH) 965 { 966 enumValue = GeoMatchConstraintValue::ML; 967 return true; 968 } 969 else if (hashCode == MT_HASH) 970 { 971 enumValue = GeoMatchConstraintValue::MT; 972 return true; 973 } 974 else if (hashCode == MH_HASH) 975 { 976 enumValue = GeoMatchConstraintValue::MH; 977 return true; 978 } 979 else if (hashCode == MQ_HASH) 980 { 981 enumValue = GeoMatchConstraintValue::MQ; 982 return true; 983 } 984 else if (hashCode == MR_HASH) 985 { 986 enumValue = GeoMatchConstraintValue::MR; 987 return true; 988 } 989 else if (hashCode == MU_HASH) 990 { 991 enumValue = GeoMatchConstraintValue::MU; 992 return true; 993 } 994 else if (hashCode == YT_HASH) 995 { 996 enumValue = GeoMatchConstraintValue::YT; 997 return true; 998 } 999 else if (hashCode == MX_HASH) 1000 { 1001 enumValue = GeoMatchConstraintValue::MX; 1002 return true; 1003 } 1004 else if (hashCode == FM_HASH) 1005 { 1006 enumValue = GeoMatchConstraintValue::FM; 1007 return true; 1008 } 1009 else if (hashCode == MD_HASH) 1010 { 1011 enumValue = GeoMatchConstraintValue::MD; 1012 return true; 1013 } 1014 else if (hashCode == MC_HASH) 1015 { 1016 enumValue = GeoMatchConstraintValue::MC; 1017 return true; 1018 } 1019 else if (hashCode == MN_HASH) 1020 { 1021 enumValue = GeoMatchConstraintValue::MN; 1022 return true; 1023 } 1024 else if (hashCode == ME_HASH) 1025 { 1026 enumValue = GeoMatchConstraintValue::ME; 1027 return true; 1028 } 1029 else if (hashCode == MS_HASH) 1030 { 1031 enumValue = GeoMatchConstraintValue::MS; 1032 return true; 1033 } 1034 else if (hashCode == MA_HASH) 1035 { 1036 enumValue = GeoMatchConstraintValue::MA; 1037 return true; 1038 } 1039 else if (hashCode == MZ_HASH) 1040 { 1041 enumValue = GeoMatchConstraintValue::MZ; 1042 return true; 1043 } 1044 else if (hashCode == MM_HASH) 1045 { 1046 enumValue = GeoMatchConstraintValue::MM; 1047 return true; 1048 } 1049 else if (hashCode == NA_HASH) 1050 { 1051 enumValue = GeoMatchConstraintValue::NA; 1052 return true; 1053 } 1054 else if (hashCode == NR_HASH) 1055 { 1056 enumValue = GeoMatchConstraintValue::NR; 1057 return true; 1058 } 1059 else if (hashCode == NP_HASH) 1060 { 1061 enumValue = GeoMatchConstraintValue::NP; 1062 return true; 1063 } 1064 else if (hashCode == NL_HASH) 1065 { 1066 enumValue = GeoMatchConstraintValue::NL; 1067 return true; 1068 } 1069 else if (hashCode == NC_HASH) 1070 { 1071 enumValue = GeoMatchConstraintValue::NC; 1072 return true; 1073 } 1074 else if (hashCode == NZ_HASH) 1075 { 1076 enumValue = GeoMatchConstraintValue::NZ; 1077 return true; 1078 } 1079 else if (hashCode == NI_HASH) 1080 { 1081 enumValue = GeoMatchConstraintValue::NI; 1082 return true; 1083 } 1084 else if (hashCode == NE_HASH) 1085 { 1086 enumValue = GeoMatchConstraintValue::NE; 1087 return true; 1088 } 1089 else if (hashCode == NG_HASH) 1090 { 1091 enumValue = GeoMatchConstraintValue::NG; 1092 return true; 1093 } 1094 else if (hashCode == NU_HASH) 1095 { 1096 enumValue = GeoMatchConstraintValue::NU; 1097 return true; 1098 } 1099 else if (hashCode == NF_HASH) 1100 { 1101 enumValue = GeoMatchConstraintValue::NF; 1102 return true; 1103 } 1104 else if (hashCode == MP_HASH) 1105 { 1106 enumValue = GeoMatchConstraintValue::MP; 1107 return true; 1108 } 1109 else if (hashCode == NO_HASH) 1110 { 1111 enumValue = GeoMatchConstraintValue::NO; 1112 return true; 1113 } 1114 else if (hashCode == OM_HASH) 1115 { 1116 enumValue = GeoMatchConstraintValue::OM; 1117 return true; 1118 } 1119 else if (hashCode == PK_HASH) 1120 { 1121 enumValue = GeoMatchConstraintValue::PK; 1122 return true; 1123 } 1124 else if (hashCode == PW_HASH) 1125 { 1126 enumValue = GeoMatchConstraintValue::PW; 1127 return true; 1128 } 1129 else if (hashCode == PS_HASH) 1130 { 1131 enumValue = GeoMatchConstraintValue::PS; 1132 return true; 1133 } 1134 else if (hashCode == PA_HASH) 1135 { 1136 enumValue = GeoMatchConstraintValue::PA; 1137 return true; 1138 } 1139 else if (hashCode == PG_HASH) 1140 { 1141 enumValue = GeoMatchConstraintValue::PG; 1142 return true; 1143 } 1144 else if (hashCode == PY_HASH) 1145 { 1146 enumValue = GeoMatchConstraintValue::PY; 1147 return true; 1148 } 1149 else if (hashCode == PE_HASH) 1150 { 1151 enumValue = GeoMatchConstraintValue::PE; 1152 return true; 1153 } 1154 else if (hashCode == PH_HASH) 1155 { 1156 enumValue = GeoMatchConstraintValue::PH; 1157 return true; 1158 } 1159 else if (hashCode == PN_HASH) 1160 { 1161 enumValue = GeoMatchConstraintValue::PN; 1162 return true; 1163 } 1164 else if (hashCode == PL_HASH) 1165 { 1166 enumValue = GeoMatchConstraintValue::PL; 1167 return true; 1168 } 1169 else if (hashCode == PT_HASH) 1170 { 1171 enumValue = GeoMatchConstraintValue::PT; 1172 return true; 1173 } 1174 else if (hashCode == PR_HASH) 1175 { 1176 enumValue = GeoMatchConstraintValue::PR; 1177 return true; 1178 } 1179 else if (hashCode == QA_HASH) 1180 { 1181 enumValue = GeoMatchConstraintValue::QA; 1182 return true; 1183 } 1184 else if (hashCode == RE_HASH) 1185 { 1186 enumValue = GeoMatchConstraintValue::RE; 1187 return true; 1188 } 1189 else if (hashCode == RO_HASH) 1190 { 1191 enumValue = GeoMatchConstraintValue::RO; 1192 return true; 1193 } 1194 else if (hashCode == RU_HASH) 1195 { 1196 enumValue = GeoMatchConstraintValue::RU; 1197 return true; 1198 } 1199 else if (hashCode == RW_HASH) 1200 { 1201 enumValue = GeoMatchConstraintValue::RW; 1202 return true; 1203 } 1204 else if (hashCode == BL_HASH) 1205 { 1206 enumValue = GeoMatchConstraintValue::BL; 1207 return true; 1208 } 1209 else if (hashCode == SH_HASH) 1210 { 1211 enumValue = GeoMatchConstraintValue::SH; 1212 return true; 1213 } 1214 else if (hashCode == KN_HASH) 1215 { 1216 enumValue = GeoMatchConstraintValue::KN; 1217 return true; 1218 } 1219 else if (hashCode == LC_HASH) 1220 { 1221 enumValue = GeoMatchConstraintValue::LC; 1222 return true; 1223 } 1224 else if (hashCode == MF_HASH) 1225 { 1226 enumValue = GeoMatchConstraintValue::MF; 1227 return true; 1228 } 1229 else if (hashCode == PM_HASH) 1230 { 1231 enumValue = GeoMatchConstraintValue::PM; 1232 return true; 1233 } 1234 else if (hashCode == VC_HASH) 1235 { 1236 enumValue = GeoMatchConstraintValue::VC; 1237 return true; 1238 } 1239 else if (hashCode == WS_HASH) 1240 { 1241 enumValue = GeoMatchConstraintValue::WS; 1242 return true; 1243 } 1244 else if (hashCode == SM_HASH) 1245 { 1246 enumValue = GeoMatchConstraintValue::SM; 1247 return true; 1248 } 1249 else if (hashCode == ST_HASH) 1250 { 1251 enumValue = GeoMatchConstraintValue::ST; 1252 return true; 1253 } 1254 else if (hashCode == SA_HASH) 1255 { 1256 enumValue = GeoMatchConstraintValue::SA; 1257 return true; 1258 } 1259 else if (hashCode == SN_HASH) 1260 { 1261 enumValue = GeoMatchConstraintValue::SN; 1262 return true; 1263 } 1264 else if (hashCode == RS_HASH) 1265 { 1266 enumValue = GeoMatchConstraintValue::RS; 1267 return true; 1268 } 1269 else if (hashCode == SC_HASH) 1270 { 1271 enumValue = GeoMatchConstraintValue::SC; 1272 return true; 1273 } 1274 else if (hashCode == SL_HASH) 1275 { 1276 enumValue = GeoMatchConstraintValue::SL; 1277 return true; 1278 } 1279 else if (hashCode == SG_HASH) 1280 { 1281 enumValue = GeoMatchConstraintValue::SG; 1282 return true; 1283 } 1284 else if (hashCode == SX_HASH) 1285 { 1286 enumValue = GeoMatchConstraintValue::SX; 1287 return true; 1288 } 1289 else if (hashCode == SK_HASH) 1290 { 1291 enumValue = GeoMatchConstraintValue::SK; 1292 return true; 1293 } 1294 else if (hashCode == SI_HASH) 1295 { 1296 enumValue = GeoMatchConstraintValue::SI; 1297 return true; 1298 } 1299 else if (hashCode == SB_HASH) 1300 { 1301 enumValue = GeoMatchConstraintValue::SB; 1302 return true; 1303 } 1304 else if (hashCode == SO_HASH) 1305 { 1306 enumValue = GeoMatchConstraintValue::SO; 1307 return true; 1308 } 1309 else if (hashCode == ZA_HASH) 1310 { 1311 enumValue = GeoMatchConstraintValue::ZA; 1312 return true; 1313 } 1314 else if (hashCode == GS_HASH) 1315 { 1316 enumValue = GeoMatchConstraintValue::GS; 1317 return true; 1318 } 1319 else if (hashCode == SS_HASH) 1320 { 1321 enumValue = GeoMatchConstraintValue::SS; 1322 return true; 1323 } 1324 else if (hashCode == ES_HASH) 1325 { 1326 enumValue = GeoMatchConstraintValue::ES; 1327 return true; 1328 } 1329 else if (hashCode == LK_HASH) 1330 { 1331 enumValue = GeoMatchConstraintValue::LK; 1332 return true; 1333 } 1334 else if (hashCode == SD_HASH) 1335 { 1336 enumValue = GeoMatchConstraintValue::SD; 1337 return true; 1338 } 1339 else if (hashCode == SR_HASH) 1340 { 1341 enumValue = GeoMatchConstraintValue::SR; 1342 return true; 1343 } 1344 else if (hashCode == SJ_HASH) 1345 { 1346 enumValue = GeoMatchConstraintValue::SJ; 1347 return true; 1348 } 1349 else if (hashCode == SZ_HASH) 1350 { 1351 enumValue = GeoMatchConstraintValue::SZ; 1352 return true; 1353 } 1354 else if (hashCode == SE_HASH) 1355 { 1356 enumValue = GeoMatchConstraintValue::SE; 1357 return true; 1358 } 1359 else if (hashCode == CH_HASH) 1360 { 1361 enumValue = GeoMatchConstraintValue::CH; 1362 return true; 1363 } 1364 else if (hashCode == SY_HASH) 1365 { 1366 enumValue = GeoMatchConstraintValue::SY; 1367 return true; 1368 } 1369 else if (hashCode == TW_HASH) 1370 { 1371 enumValue = GeoMatchConstraintValue::TW; 1372 return true; 1373 } 1374 else if (hashCode == TJ_HASH) 1375 { 1376 enumValue = GeoMatchConstraintValue::TJ; 1377 return true; 1378 } 1379 else if (hashCode == TZ_HASH) 1380 { 1381 enumValue = GeoMatchConstraintValue::TZ; 1382 return true; 1383 } 1384 else if (hashCode == TH_HASH) 1385 { 1386 enumValue = GeoMatchConstraintValue::TH; 1387 return true; 1388 } 1389 else if (hashCode == TL_HASH) 1390 { 1391 enumValue = GeoMatchConstraintValue::TL; 1392 return true; 1393 } 1394 else if (hashCode == TG_HASH) 1395 { 1396 enumValue = GeoMatchConstraintValue::TG; 1397 return true; 1398 } 1399 else if (hashCode == TK_HASH) 1400 { 1401 enumValue = GeoMatchConstraintValue::TK; 1402 return true; 1403 } 1404 else if (hashCode == TO_HASH) 1405 { 1406 enumValue = GeoMatchConstraintValue::TO; 1407 return true; 1408 } 1409 else if (hashCode == TT_HASH) 1410 { 1411 enumValue = GeoMatchConstraintValue::TT; 1412 return true; 1413 } 1414 else if (hashCode == TN_HASH) 1415 { 1416 enumValue = GeoMatchConstraintValue::TN; 1417 return true; 1418 } 1419 else if (hashCode == TR_HASH) 1420 { 1421 enumValue = GeoMatchConstraintValue::TR; 1422 return true; 1423 } 1424 else if (hashCode == TM_HASH) 1425 { 1426 enumValue = GeoMatchConstraintValue::TM; 1427 return true; 1428 } 1429 else if (hashCode == TC_HASH) 1430 { 1431 enumValue = GeoMatchConstraintValue::TC; 1432 return true; 1433 } 1434 else if (hashCode == TV_HASH) 1435 { 1436 enumValue = GeoMatchConstraintValue::TV; 1437 return true; 1438 } 1439 else if (hashCode == UG_HASH) 1440 { 1441 enumValue = GeoMatchConstraintValue::UG; 1442 return true; 1443 } 1444 else if (hashCode == UA_HASH) 1445 { 1446 enumValue = GeoMatchConstraintValue::UA; 1447 return true; 1448 } 1449 else if (hashCode == AE_HASH) 1450 { 1451 enumValue = GeoMatchConstraintValue::AE; 1452 return true; 1453 } 1454 else if (hashCode == GB_HASH) 1455 { 1456 enumValue = GeoMatchConstraintValue::GB; 1457 return true; 1458 } 1459 else if (hashCode == US_HASH) 1460 { 1461 enumValue = GeoMatchConstraintValue::US; 1462 return true; 1463 } 1464 else if (hashCode == UM_HASH) 1465 { 1466 enumValue = GeoMatchConstraintValue::UM; 1467 return true; 1468 } 1469 else if (hashCode == UY_HASH) 1470 { 1471 enumValue = GeoMatchConstraintValue::UY; 1472 return true; 1473 } 1474 else if (hashCode == UZ_HASH) 1475 { 1476 enumValue = GeoMatchConstraintValue::UZ; 1477 return true; 1478 } 1479 else if (hashCode == VU_HASH) 1480 { 1481 enumValue = GeoMatchConstraintValue::VU; 1482 return true; 1483 } 1484 else if (hashCode == VE_HASH) 1485 { 1486 enumValue = GeoMatchConstraintValue::VE; 1487 return true; 1488 } 1489 else if (hashCode == VN_HASH) 1490 { 1491 enumValue = GeoMatchConstraintValue::VN; 1492 return true; 1493 } 1494 else if (hashCode == VG_HASH) 1495 { 1496 enumValue = GeoMatchConstraintValue::VG; 1497 return true; 1498 } 1499 else if (hashCode == VI_HASH) 1500 { 1501 enumValue = GeoMatchConstraintValue::VI; 1502 return true; 1503 } 1504 return false; 1505 } GetEnumForNameHelper2(int hashCode,GeoMatchConstraintValue & enumValue)1506 static bool GetEnumForNameHelper2(int hashCode, GeoMatchConstraintValue& enumValue) 1507 { 1508 if (hashCode == WF_HASH) 1509 { 1510 enumValue = GeoMatchConstraintValue::WF; 1511 return true; 1512 } 1513 else if (hashCode == EH_HASH) 1514 { 1515 enumValue = GeoMatchConstraintValue::EH; 1516 return true; 1517 } 1518 else if (hashCode == YE_HASH) 1519 { 1520 enumValue = GeoMatchConstraintValue::YE; 1521 return true; 1522 } 1523 else if (hashCode == ZM_HASH) 1524 { 1525 enumValue = GeoMatchConstraintValue::ZM; 1526 return true; 1527 } 1528 else if (hashCode == ZW_HASH) 1529 { 1530 enumValue = GeoMatchConstraintValue::ZW; 1531 return true; 1532 } 1533 return false; 1534 } 1535 GetNameForEnumHelper0(GeoMatchConstraintValue enumValue,Aws::String & value)1536 static bool GetNameForEnumHelper0(GeoMatchConstraintValue enumValue, Aws::String& value) 1537 { 1538 switch(enumValue) 1539 { 1540 case GeoMatchConstraintValue::AF: 1541 value = "AF"; 1542 return true; 1543 case GeoMatchConstraintValue::AX: 1544 value = "AX"; 1545 return true; 1546 case GeoMatchConstraintValue::AL: 1547 value = "AL"; 1548 return true; 1549 case GeoMatchConstraintValue::DZ: 1550 value = "DZ"; 1551 return true; 1552 case GeoMatchConstraintValue::AS: 1553 value = "AS"; 1554 return true; 1555 case GeoMatchConstraintValue::AD: 1556 value = "AD"; 1557 return true; 1558 case GeoMatchConstraintValue::AO: 1559 value = "AO"; 1560 return true; 1561 case GeoMatchConstraintValue::AI: 1562 value = "AI"; 1563 return true; 1564 case GeoMatchConstraintValue::AQ: 1565 value = "AQ"; 1566 return true; 1567 case GeoMatchConstraintValue::AG: 1568 value = "AG"; 1569 return true; 1570 case GeoMatchConstraintValue::AR: 1571 value = "AR"; 1572 return true; 1573 case GeoMatchConstraintValue::AM: 1574 value = "AM"; 1575 return true; 1576 case GeoMatchConstraintValue::AW: 1577 value = "AW"; 1578 return true; 1579 case GeoMatchConstraintValue::AU: 1580 value = "AU"; 1581 return true; 1582 case GeoMatchConstraintValue::AT: 1583 value = "AT"; 1584 return true; 1585 case GeoMatchConstraintValue::AZ: 1586 value = "AZ"; 1587 return true; 1588 case GeoMatchConstraintValue::BS: 1589 value = "BS"; 1590 return true; 1591 case GeoMatchConstraintValue::BH: 1592 value = "BH"; 1593 return true; 1594 case GeoMatchConstraintValue::BD: 1595 value = "BD"; 1596 return true; 1597 case GeoMatchConstraintValue::BB: 1598 value = "BB"; 1599 return true; 1600 case GeoMatchConstraintValue::BY: 1601 value = "BY"; 1602 return true; 1603 case GeoMatchConstraintValue::BE: 1604 value = "BE"; 1605 return true; 1606 case GeoMatchConstraintValue::BZ: 1607 value = "BZ"; 1608 return true; 1609 case GeoMatchConstraintValue::BJ: 1610 value = "BJ"; 1611 return true; 1612 case GeoMatchConstraintValue::BM: 1613 value = "BM"; 1614 return true; 1615 case GeoMatchConstraintValue::BT: 1616 value = "BT"; 1617 return true; 1618 case GeoMatchConstraintValue::BO: 1619 value = "BO"; 1620 return true; 1621 case GeoMatchConstraintValue::BQ: 1622 value = "BQ"; 1623 return true; 1624 case GeoMatchConstraintValue::BA: 1625 value = "BA"; 1626 return true; 1627 case GeoMatchConstraintValue::BW: 1628 value = "BW"; 1629 return true; 1630 case GeoMatchConstraintValue::BV: 1631 value = "BV"; 1632 return true; 1633 case GeoMatchConstraintValue::BR: 1634 value = "BR"; 1635 return true; 1636 case GeoMatchConstraintValue::IO: 1637 value = "IO"; 1638 return true; 1639 case GeoMatchConstraintValue::BN: 1640 value = "BN"; 1641 return true; 1642 case GeoMatchConstraintValue::BG: 1643 value = "BG"; 1644 return true; 1645 case GeoMatchConstraintValue::BF: 1646 value = "BF"; 1647 return true; 1648 case GeoMatchConstraintValue::BI: 1649 value = "BI"; 1650 return true; 1651 case GeoMatchConstraintValue::KH: 1652 value = "KH"; 1653 return true; 1654 case GeoMatchConstraintValue::CM: 1655 value = "CM"; 1656 return true; 1657 case GeoMatchConstraintValue::CA: 1658 value = "CA"; 1659 return true; 1660 case GeoMatchConstraintValue::CV: 1661 value = "CV"; 1662 return true; 1663 case GeoMatchConstraintValue::KY: 1664 value = "KY"; 1665 return true; 1666 case GeoMatchConstraintValue::CF: 1667 value = "CF"; 1668 return true; 1669 case GeoMatchConstraintValue::TD: 1670 value = "TD"; 1671 return true; 1672 case GeoMatchConstraintValue::CL: 1673 value = "CL"; 1674 return true; 1675 case GeoMatchConstraintValue::CN: 1676 value = "CN"; 1677 return true; 1678 case GeoMatchConstraintValue::CX: 1679 value = "CX"; 1680 return true; 1681 case GeoMatchConstraintValue::CC: 1682 value = "CC"; 1683 return true; 1684 case GeoMatchConstraintValue::CO: 1685 value = "CO"; 1686 return true; 1687 case GeoMatchConstraintValue::KM: 1688 value = "KM"; 1689 return true; 1690 case GeoMatchConstraintValue::CG: 1691 value = "CG"; 1692 return true; 1693 case GeoMatchConstraintValue::CD: 1694 value = "CD"; 1695 return true; 1696 case GeoMatchConstraintValue::CK: 1697 value = "CK"; 1698 return true; 1699 case GeoMatchConstraintValue::CR: 1700 value = "CR"; 1701 return true; 1702 case GeoMatchConstraintValue::CI: 1703 value = "CI"; 1704 return true; 1705 case GeoMatchConstraintValue::HR: 1706 value = "HR"; 1707 return true; 1708 case GeoMatchConstraintValue::CU: 1709 value = "CU"; 1710 return true; 1711 case GeoMatchConstraintValue::CW: 1712 value = "CW"; 1713 return true; 1714 case GeoMatchConstraintValue::CY: 1715 value = "CY"; 1716 return true; 1717 case GeoMatchConstraintValue::CZ: 1718 value = "CZ"; 1719 return true; 1720 case GeoMatchConstraintValue::DK: 1721 value = "DK"; 1722 return true; 1723 case GeoMatchConstraintValue::DJ: 1724 value = "DJ"; 1725 return true; 1726 case GeoMatchConstraintValue::DM: 1727 value = "DM"; 1728 return true; 1729 case GeoMatchConstraintValue::DO: 1730 value = "DO"; 1731 return true; 1732 case GeoMatchConstraintValue::EC: 1733 value = "EC"; 1734 return true; 1735 case GeoMatchConstraintValue::EG: 1736 value = "EG"; 1737 return true; 1738 case GeoMatchConstraintValue::SV: 1739 value = "SV"; 1740 return true; 1741 case GeoMatchConstraintValue::GQ: 1742 value = "GQ"; 1743 return true; 1744 case GeoMatchConstraintValue::ER: 1745 value = "ER"; 1746 return true; 1747 case GeoMatchConstraintValue::EE: 1748 value = "EE"; 1749 return true; 1750 case GeoMatchConstraintValue::ET: 1751 value = "ET"; 1752 return true; 1753 case GeoMatchConstraintValue::FK: 1754 value = "FK"; 1755 return true; 1756 case GeoMatchConstraintValue::FO: 1757 value = "FO"; 1758 return true; 1759 case GeoMatchConstraintValue::FJ: 1760 value = "FJ"; 1761 return true; 1762 case GeoMatchConstraintValue::FI: 1763 value = "FI"; 1764 return true; 1765 case GeoMatchConstraintValue::FR: 1766 value = "FR"; 1767 return true; 1768 case GeoMatchConstraintValue::GF: 1769 value = "GF"; 1770 return true; 1771 case GeoMatchConstraintValue::PF: 1772 value = "PF"; 1773 return true; 1774 case GeoMatchConstraintValue::TF: 1775 value = "TF"; 1776 return true; 1777 case GeoMatchConstraintValue::GA: 1778 value = "GA"; 1779 return true; 1780 case GeoMatchConstraintValue::GM: 1781 value = "GM"; 1782 return true; 1783 case GeoMatchConstraintValue::GE: 1784 value = "GE"; 1785 return true; 1786 case GeoMatchConstraintValue::DE: 1787 value = "DE"; 1788 return true; 1789 case GeoMatchConstraintValue::GH: 1790 value = "GH"; 1791 return true; 1792 case GeoMatchConstraintValue::GI: 1793 value = "GI"; 1794 return true; 1795 case GeoMatchConstraintValue::GR: 1796 value = "GR"; 1797 return true; 1798 case GeoMatchConstraintValue::GL: 1799 value = "GL"; 1800 return true; 1801 case GeoMatchConstraintValue::GD: 1802 value = "GD"; 1803 return true; 1804 case GeoMatchConstraintValue::GP: 1805 value = "GP"; 1806 return true; 1807 case GeoMatchConstraintValue::GU: 1808 value = "GU"; 1809 return true; 1810 case GeoMatchConstraintValue::GT: 1811 value = "GT"; 1812 return true; 1813 case GeoMatchConstraintValue::GG: 1814 value = "GG"; 1815 return true; 1816 case GeoMatchConstraintValue::GN: 1817 value = "GN"; 1818 return true; 1819 case GeoMatchConstraintValue::GW: 1820 value = "GW"; 1821 return true; 1822 case GeoMatchConstraintValue::GY: 1823 value = "GY"; 1824 return true; 1825 case GeoMatchConstraintValue::HT: 1826 value = "HT"; 1827 return true; 1828 case GeoMatchConstraintValue::HM: 1829 value = "HM"; 1830 return true; 1831 case GeoMatchConstraintValue::VA: 1832 value = "VA"; 1833 return true; 1834 case GeoMatchConstraintValue::HN: 1835 value = "HN"; 1836 return true; 1837 case GeoMatchConstraintValue::HK: 1838 value = "HK"; 1839 return true; 1840 case GeoMatchConstraintValue::HU: 1841 value = "HU"; 1842 return true; 1843 case GeoMatchConstraintValue::IS: 1844 value = "IS"; 1845 return true; 1846 case GeoMatchConstraintValue::IN: 1847 value = "IN"; 1848 return true; 1849 case GeoMatchConstraintValue::ID: 1850 value = "ID"; 1851 return true; 1852 case GeoMatchConstraintValue::IR: 1853 value = "IR"; 1854 return true; 1855 case GeoMatchConstraintValue::IQ: 1856 value = "IQ"; 1857 return true; 1858 case GeoMatchConstraintValue::IE: 1859 value = "IE"; 1860 return true; 1861 case GeoMatchConstraintValue::IM: 1862 value = "IM"; 1863 return true; 1864 case GeoMatchConstraintValue::IL: 1865 value = "IL"; 1866 return true; 1867 case GeoMatchConstraintValue::IT: 1868 value = "IT"; 1869 return true; 1870 case GeoMatchConstraintValue::JM: 1871 value = "JM"; 1872 return true; 1873 case GeoMatchConstraintValue::JP: 1874 value = "JP"; 1875 return true; 1876 case GeoMatchConstraintValue::JE: 1877 value = "JE"; 1878 return true; 1879 case GeoMatchConstraintValue::JO: 1880 value = "JO"; 1881 return true; 1882 case GeoMatchConstraintValue::KZ: 1883 value = "KZ"; 1884 return true; 1885 case GeoMatchConstraintValue::KE: 1886 value = "KE"; 1887 return true; 1888 case GeoMatchConstraintValue::KI: 1889 value = "KI"; 1890 return true; 1891 case GeoMatchConstraintValue::KP: 1892 value = "KP"; 1893 return true; 1894 case GeoMatchConstraintValue::KR: 1895 value = "KR"; 1896 return true; 1897 case GeoMatchConstraintValue::KW: 1898 value = "KW"; 1899 return true; 1900 case GeoMatchConstraintValue::KG: 1901 value = "KG"; 1902 return true; 1903 case GeoMatchConstraintValue::LA: 1904 value = "LA"; 1905 return true; 1906 default: 1907 return false; 1908 } 1909 } GetNameForEnumHelper1(GeoMatchConstraintValue enumValue,Aws::String & value)1910 static bool GetNameForEnumHelper1(GeoMatchConstraintValue enumValue, Aws::String& value) 1911 { 1912 switch(enumValue) 1913 { 1914 case GeoMatchConstraintValue::LV: 1915 value = "LV"; 1916 return true; 1917 case GeoMatchConstraintValue::LB: 1918 value = "LB"; 1919 return true; 1920 case GeoMatchConstraintValue::LS: 1921 value = "LS"; 1922 return true; 1923 case GeoMatchConstraintValue::LR: 1924 value = "LR"; 1925 return true; 1926 case GeoMatchConstraintValue::LY: 1927 value = "LY"; 1928 return true; 1929 case GeoMatchConstraintValue::LI: 1930 value = "LI"; 1931 return true; 1932 case GeoMatchConstraintValue::LT: 1933 value = "LT"; 1934 return true; 1935 case GeoMatchConstraintValue::LU: 1936 value = "LU"; 1937 return true; 1938 case GeoMatchConstraintValue::MO: 1939 value = "MO"; 1940 return true; 1941 case GeoMatchConstraintValue::MK: 1942 value = "MK"; 1943 return true; 1944 case GeoMatchConstraintValue::MG: 1945 value = "MG"; 1946 return true; 1947 case GeoMatchConstraintValue::MW: 1948 value = "MW"; 1949 return true; 1950 case GeoMatchConstraintValue::MY: 1951 value = "MY"; 1952 return true; 1953 case GeoMatchConstraintValue::MV: 1954 value = "MV"; 1955 return true; 1956 case GeoMatchConstraintValue::ML: 1957 value = "ML"; 1958 return true; 1959 case GeoMatchConstraintValue::MT: 1960 value = "MT"; 1961 return true; 1962 case GeoMatchConstraintValue::MH: 1963 value = "MH"; 1964 return true; 1965 case GeoMatchConstraintValue::MQ: 1966 value = "MQ"; 1967 return true; 1968 case GeoMatchConstraintValue::MR: 1969 value = "MR"; 1970 return true; 1971 case GeoMatchConstraintValue::MU: 1972 value = "MU"; 1973 return true; 1974 case GeoMatchConstraintValue::YT: 1975 value = "YT"; 1976 return true; 1977 case GeoMatchConstraintValue::MX: 1978 value = "MX"; 1979 return true; 1980 case GeoMatchConstraintValue::FM: 1981 value = "FM"; 1982 return true; 1983 case GeoMatchConstraintValue::MD: 1984 value = "MD"; 1985 return true; 1986 case GeoMatchConstraintValue::MC: 1987 value = "MC"; 1988 return true; 1989 case GeoMatchConstraintValue::MN: 1990 value = "MN"; 1991 return true; 1992 case GeoMatchConstraintValue::ME: 1993 value = "ME"; 1994 return true; 1995 case GeoMatchConstraintValue::MS: 1996 value = "MS"; 1997 return true; 1998 case GeoMatchConstraintValue::MA: 1999 value = "MA"; 2000 return true; 2001 case GeoMatchConstraintValue::MZ: 2002 value = "MZ"; 2003 return true; 2004 case GeoMatchConstraintValue::MM: 2005 value = "MM"; 2006 return true; 2007 case GeoMatchConstraintValue::NA: 2008 value = "NA"; 2009 return true; 2010 case GeoMatchConstraintValue::NR: 2011 value = "NR"; 2012 return true; 2013 case GeoMatchConstraintValue::NP: 2014 value = "NP"; 2015 return true; 2016 case GeoMatchConstraintValue::NL: 2017 value = "NL"; 2018 return true; 2019 case GeoMatchConstraintValue::NC: 2020 value = "NC"; 2021 return true; 2022 case GeoMatchConstraintValue::NZ: 2023 value = "NZ"; 2024 return true; 2025 case GeoMatchConstraintValue::NI: 2026 value = "NI"; 2027 return true; 2028 case GeoMatchConstraintValue::NE: 2029 value = "NE"; 2030 return true; 2031 case GeoMatchConstraintValue::NG: 2032 value = "NG"; 2033 return true; 2034 case GeoMatchConstraintValue::NU: 2035 value = "NU"; 2036 return true; 2037 case GeoMatchConstraintValue::NF: 2038 value = "NF"; 2039 return true; 2040 case GeoMatchConstraintValue::MP: 2041 value = "MP"; 2042 return true; 2043 case GeoMatchConstraintValue::NO: 2044 value = "NO"; 2045 return true; 2046 case GeoMatchConstraintValue::OM: 2047 value = "OM"; 2048 return true; 2049 case GeoMatchConstraintValue::PK: 2050 value = "PK"; 2051 return true; 2052 case GeoMatchConstraintValue::PW: 2053 value = "PW"; 2054 return true; 2055 case GeoMatchConstraintValue::PS: 2056 value = "PS"; 2057 return true; 2058 case GeoMatchConstraintValue::PA: 2059 value = "PA"; 2060 return true; 2061 case GeoMatchConstraintValue::PG: 2062 value = "PG"; 2063 return true; 2064 case GeoMatchConstraintValue::PY: 2065 value = "PY"; 2066 return true; 2067 case GeoMatchConstraintValue::PE: 2068 value = "PE"; 2069 return true; 2070 case GeoMatchConstraintValue::PH: 2071 value = "PH"; 2072 return true; 2073 case GeoMatchConstraintValue::PN: 2074 value = "PN"; 2075 return true; 2076 case GeoMatchConstraintValue::PL: 2077 value = "PL"; 2078 return true; 2079 case GeoMatchConstraintValue::PT: 2080 value = "PT"; 2081 return true; 2082 case GeoMatchConstraintValue::PR: 2083 value = "PR"; 2084 return true; 2085 case GeoMatchConstraintValue::QA: 2086 value = "QA"; 2087 return true; 2088 case GeoMatchConstraintValue::RE: 2089 value = "RE"; 2090 return true; 2091 case GeoMatchConstraintValue::RO: 2092 value = "RO"; 2093 return true; 2094 case GeoMatchConstraintValue::RU: 2095 value = "RU"; 2096 return true; 2097 case GeoMatchConstraintValue::RW: 2098 value = "RW"; 2099 return true; 2100 case GeoMatchConstraintValue::BL: 2101 value = "BL"; 2102 return true; 2103 case GeoMatchConstraintValue::SH: 2104 value = "SH"; 2105 return true; 2106 case GeoMatchConstraintValue::KN: 2107 value = "KN"; 2108 return true; 2109 case GeoMatchConstraintValue::LC: 2110 value = "LC"; 2111 return true; 2112 case GeoMatchConstraintValue::MF: 2113 value = "MF"; 2114 return true; 2115 case GeoMatchConstraintValue::PM: 2116 value = "PM"; 2117 return true; 2118 case GeoMatchConstraintValue::VC: 2119 value = "VC"; 2120 return true; 2121 case GeoMatchConstraintValue::WS: 2122 value = "WS"; 2123 return true; 2124 case GeoMatchConstraintValue::SM: 2125 value = "SM"; 2126 return true; 2127 case GeoMatchConstraintValue::ST: 2128 value = "ST"; 2129 return true; 2130 case GeoMatchConstraintValue::SA: 2131 value = "SA"; 2132 return true; 2133 case GeoMatchConstraintValue::SN: 2134 value = "SN"; 2135 return true; 2136 case GeoMatchConstraintValue::RS: 2137 value = "RS"; 2138 return true; 2139 case GeoMatchConstraintValue::SC: 2140 value = "SC"; 2141 return true; 2142 case GeoMatchConstraintValue::SL: 2143 value = "SL"; 2144 return true; 2145 case GeoMatchConstraintValue::SG: 2146 value = "SG"; 2147 return true; 2148 case GeoMatchConstraintValue::SX: 2149 value = "SX"; 2150 return true; 2151 case GeoMatchConstraintValue::SK: 2152 value = "SK"; 2153 return true; 2154 case GeoMatchConstraintValue::SI: 2155 value = "SI"; 2156 return true; 2157 case GeoMatchConstraintValue::SB: 2158 value = "SB"; 2159 return true; 2160 case GeoMatchConstraintValue::SO: 2161 value = "SO"; 2162 return true; 2163 case GeoMatchConstraintValue::ZA: 2164 value = "ZA"; 2165 return true; 2166 case GeoMatchConstraintValue::GS: 2167 value = "GS"; 2168 return true; 2169 case GeoMatchConstraintValue::SS: 2170 value = "SS"; 2171 return true; 2172 case GeoMatchConstraintValue::ES: 2173 value = "ES"; 2174 return true; 2175 case GeoMatchConstraintValue::LK: 2176 value = "LK"; 2177 return true; 2178 case GeoMatchConstraintValue::SD: 2179 value = "SD"; 2180 return true; 2181 case GeoMatchConstraintValue::SR: 2182 value = "SR"; 2183 return true; 2184 case GeoMatchConstraintValue::SJ: 2185 value = "SJ"; 2186 return true; 2187 case GeoMatchConstraintValue::SZ: 2188 value = "SZ"; 2189 return true; 2190 case GeoMatchConstraintValue::SE: 2191 value = "SE"; 2192 return true; 2193 case GeoMatchConstraintValue::CH: 2194 value = "CH"; 2195 return true; 2196 case GeoMatchConstraintValue::SY: 2197 value = "SY"; 2198 return true; 2199 case GeoMatchConstraintValue::TW: 2200 value = "TW"; 2201 return true; 2202 case GeoMatchConstraintValue::TJ: 2203 value = "TJ"; 2204 return true; 2205 case GeoMatchConstraintValue::TZ: 2206 value = "TZ"; 2207 return true; 2208 case GeoMatchConstraintValue::TH: 2209 value = "TH"; 2210 return true; 2211 case GeoMatchConstraintValue::TL: 2212 value = "TL"; 2213 return true; 2214 case GeoMatchConstraintValue::TG: 2215 value = "TG"; 2216 return true; 2217 case GeoMatchConstraintValue::TK: 2218 value = "TK"; 2219 return true; 2220 case GeoMatchConstraintValue::TO: 2221 value = "TO"; 2222 return true; 2223 case GeoMatchConstraintValue::TT: 2224 value = "TT"; 2225 return true; 2226 case GeoMatchConstraintValue::TN: 2227 value = "TN"; 2228 return true; 2229 case GeoMatchConstraintValue::TR: 2230 value = "TR"; 2231 return true; 2232 case GeoMatchConstraintValue::TM: 2233 value = "TM"; 2234 return true; 2235 case GeoMatchConstraintValue::TC: 2236 value = "TC"; 2237 return true; 2238 case GeoMatchConstraintValue::TV: 2239 value = "TV"; 2240 return true; 2241 case GeoMatchConstraintValue::UG: 2242 value = "UG"; 2243 return true; 2244 case GeoMatchConstraintValue::UA: 2245 value = "UA"; 2246 return true; 2247 case GeoMatchConstraintValue::AE: 2248 value = "AE"; 2249 return true; 2250 case GeoMatchConstraintValue::GB: 2251 value = "GB"; 2252 return true; 2253 case GeoMatchConstraintValue::US: 2254 value = "US"; 2255 return true; 2256 case GeoMatchConstraintValue::UM: 2257 value = "UM"; 2258 return true; 2259 case GeoMatchConstraintValue::UY: 2260 value = "UY"; 2261 return true; 2262 case GeoMatchConstraintValue::UZ: 2263 value = "UZ"; 2264 return true; 2265 case GeoMatchConstraintValue::VU: 2266 value = "VU"; 2267 return true; 2268 case GeoMatchConstraintValue::VE: 2269 value = "VE"; 2270 return true; 2271 case GeoMatchConstraintValue::VN: 2272 value = "VN"; 2273 return true; 2274 case GeoMatchConstraintValue::VG: 2275 value = "VG"; 2276 return true; 2277 case GeoMatchConstraintValue::VI: 2278 value = "VI"; 2279 return true; 2280 default: 2281 return false; 2282 } 2283 } GetNameForEnumHelper2(GeoMatchConstraintValue enumValue,Aws::String & value)2284 static bool GetNameForEnumHelper2(GeoMatchConstraintValue enumValue, Aws::String& value) 2285 { 2286 switch(enumValue) 2287 { 2288 case GeoMatchConstraintValue::WF: 2289 value = "WF"; 2290 return true; 2291 case GeoMatchConstraintValue::EH: 2292 value = "EH"; 2293 return true; 2294 case GeoMatchConstraintValue::YE: 2295 value = "YE"; 2296 return true; 2297 case GeoMatchConstraintValue::ZM: 2298 value = "ZM"; 2299 return true; 2300 case GeoMatchConstraintValue::ZW: 2301 value = "ZW"; 2302 return true; 2303 default: 2304 return false; 2305 } 2306 } 2307 GetGeoMatchConstraintValueForName(const Aws::String & name)2308 GeoMatchConstraintValue GetGeoMatchConstraintValueForName(const Aws::String& name) 2309 { 2310 int hashCode = HashingUtils::HashString(name.c_str()); 2311 GeoMatchConstraintValue enumValue; 2312 if (GetEnumForNameHelper0(hashCode, enumValue)) 2313 { 2314 return enumValue; 2315 } 2316 else if (GetEnumForNameHelper1(hashCode, enumValue)) 2317 { 2318 return enumValue; 2319 } 2320 else if (GetEnumForNameHelper2(hashCode, enumValue)) 2321 { 2322 return enumValue; 2323 } 2324 EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); 2325 if(overflowContainer) 2326 { 2327 overflowContainer->StoreOverflow(hashCode, name); 2328 return static_cast<GeoMatchConstraintValue>(hashCode); 2329 } 2330 2331 return GeoMatchConstraintValue::NOT_SET; 2332 } 2333 GetNameForGeoMatchConstraintValue(GeoMatchConstraintValue enumValue)2334 Aws::String GetNameForGeoMatchConstraintValue(GeoMatchConstraintValue enumValue) 2335 { 2336 Aws::String value; 2337 if (GetNameForEnumHelper0(enumValue, value)) 2338 { 2339 return value; 2340 } 2341 else if (GetNameForEnumHelper1(enumValue, value)) 2342 { 2343 return value; 2344 } 2345 else if (GetNameForEnumHelper2(enumValue, value)) 2346 { 2347 return value; 2348 } 2349 EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); 2350 if(overflowContainer) 2351 { 2352 return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue)); 2353 } 2354 2355 return {}; 2356 } 2357 2358 } // namespace GeoMatchConstraintValueMapper 2359 } // namespace Model 2360 } // namespace WAF 2361 } // namespace Aws 2362