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